From 62c8edc039852ac662ca6ae7f7fb92009e8bdc1b Mon Sep 17 00:00:00 2001 From: Yat Ho Date: Thu, 25 Dec 2025 03:29:59 +0800 Subject: [PATCH] refactor: use `api_compat` for rpc (#7995) * fix: legacy RPC tag should ignore non-integers * refactor: delegate legacy RPC callback to api-compat * refactor: move `TR_KEY_alt_speed_down_kebab` handling * refactor: move `TR_KEY_alt_speed_enabled_kebab` handling * refactor: move `TR_KEY_alt_speed_time_begin_kebab` handling * refactor: move `TR_KEY_alt_speed_time_day_kebab` handling * refactor: move `TR_KEY_alt_speed_time_enabled_kebab` handling * refactor: move `TR_KEY_alt_speed_time_end_kebab` handling * refactor: move `TR_KEY_alt_speed_up_kebab` handling * refactor: move `TR_KEY_anti_brute_force_enabled_kebab` handling * refactor: move `TR_KEY_anti_brute_force_threshold_kebab` handling * refactor: move `TR_KEY_blocklist_enabled_kebab` handling * refactor: move `TR_KEY_blocklist_size_kebab` handling * refactor: move `TR_KEY_blocklist_url_kebab` handling * refactor: move `TR_KEY_cache_size_mb_kebab` handling * refactor: move `TR_KEY_config_dir_kebab` handling * refactor: move `TR_KEY_default_trackers_kebab` handling * refactor: move `TR_KEY_dht_enabled_kebab` handling * refactor: move `TR_KEY_download_dir_kebab` handling * refactor: move `TR_KEY_download_dir_free_space_kebab` handling * refactor: move `TR_KEY_download_queue_enabled_kebab` handling * refactor: move `TR_KEY_download_queue_size_kebab` handling * refactor: move `TR_KEY_idle_seeding_limit_kebab` handling * refactor: move `TR_KEY_idle_seeding_limit_enabled_kebab` handling * refactor: move `TR_KEY_incomplete_dir_kebab` handling * refactor: move `TR_KEY_incomplete_dir_enabled_kebab` handling * refactor: move `TR_KEY_lpd_enabled_kebab` handling * refactor: move `TR_KEY_peer_limit_global_kebab` handling * refactor: move `TR_KEY_peer_limit_per_torrent_kebab` handling * refactor: move `TR_KEY_peer_port_kebab` handling * refactor: move `TR_KEY_peer_port_random_on_start_kebab` handling * refactor: move `TR_KEY_pex_enabled_kebab` handling * refactor: move `TR_KEY_port_forwarding_enabled_kebab` handling * refactor: move `TR_KEY_queue_stalled_enabled_kebab` handling * refactor: move `TR_KEY_queue_stalled_minutes_kebab` handling * refactor: move `TR_KEY_rename_partial_files_kebab` handling * refactor: move `TR_KEY_rpc_version_kebab` handling * refactor: move `TR_KEY_rpc_version_minimum_kebab` handling * refactor: move `TR_KEY_rpc_version_semver_kebab` handling * refactor: move `TR_KEY_script_torrent_added_enabled_kebab` handling * refactor: move `TR_KEY_script_torrent_added_filename_kebab` handling * refactor: move `TR_KEY_script_torrent_done_enabled_kebab` handling * refactor: move `TR_KEY_script_torrent_done_filename_kebab` handling * refactor: move `TR_KEY_script_torrent_done_seeding_enabled_kebab` handling * refactor: move `TR_KEY_script_torrent_done_seeding_filename_kebab` handling * refactor: remove `tr_quark_convert` usage for `tr_session::Scripts` * refactor: move `TR_KEY_seed_ratio_limit_camel` handling * refactor: move `TR_KEY_seed_ratio_limited_camel` handling * refactor: move `TR_KEY_seed_queue_enabled_kebab` handling * refactor: move `TR_KEY_seed_queue_size_kebab` handling * refactor: move `TR_KEY_session_id_kebab` handling * refactor: move `TR_KEY_speed_limit_down_kebab` handling * refactor: move `TR_KEY_speed_limit_down_enabled_kebab` handling * refactor: move `TR_KEY_speed_limit_up_kebab` handling * refactor: move `TR_KEY_speed_limit_up_enabled_kebab` handling * refactor: move `TR_KEY_start_added_torrents_kebab` handling * refactor: move `TR_KEY_tcp_enabled_kebab` handling * refactor: move `TR_KEY_trash_original_torrent_files_kebab` handling * refactor: move `TR_KEY_utp_enabled_kebab` handling * refactor: move `TR_KEY_recently_active_kebab` handling * refactor: move `TR_KEY_delete_local_data_kebab` handling * refactor: move `TR_KEY_activity_date_camel` handling * refactor: move `TR_KEY_added_date_camel` handling * refactor: move `TR_KEY_bandwidth_priority_camel` handling * refactor: move `TR_KEY_bytes_completed_camel` handling * refactor: move `TR_KEY_corrupt_ever_camel` handling * refactor: move `TR_KEY_date_created_camel` handling * refactor: move `TR_KEY_desired_available_camel` handling * refactor: move `TR_KEY_done_date_camel` handling * refactor: move `TR_KEY_download_dir_camel` handling * refactor: move `TR_KEY_download_limit_camel` handling * refactor: move `TR_KEY_download_limited_camel` handling * refactor: move `TR_KEY_downloaded_ever_camel` handling * refactor: move `TR_KEY_edit_date_camel` handling * refactor: move `TR_KEY_error_string_camel` handling * refactor: move `TR_KEY_eta_idle_camel` handling * refactor: move `TR_KEY_file_stats_camel` handling * refactor: move `TR_KEY_file_count_kebab` handling * refactor: move `TR_KEY_hash_string_camel` handling * refactor: move `TR_KEY_have_unchecked_camel` handling * refactor: move `TR_KEY_have_valid_camel` handling * refactor: move `TR_KEY_honors_session_limits_camel` handling * refactor: move `TR_KEY_is_finished_camel` handling * refactor: move `TR_KEY_is_private_camel` handling * refactor: move `TR_KEY_is_stalled_camel` handling * refactor: move `TR_KEY_left_until_done_camel` handling * refactor: move `TR_KEY_magnet_link_camel` handling * refactor: move `TR_KEY_manual_announce_time_camel` handling * refactor: move `TR_KEY_max_connected_peers_camel` handling * refactor: move `TR_KEY_metadata_percent_complete_camel` handling * refactor: move `TR_KEY_peer_limit_kebab` handling * refactor: move `TR_KEY_peers_connected_camel` handling * refactor: move `TR_KEY_peers_from_camel` handling * refactor: move `TR_KEY_peers_getting_from_us_camel` handling * refactor: move `TR_KEY_peers_sending_to_us_camel` handling * refactor: move `TR_KEY_percent_complete_camel` handling * refactor: move `TR_KEY_percent_done_camel` handling * refactor: move `TR_KEY_piece_count_camel` handling * refactor: move `TR_KEY_piece_size_camel` handling * refactor: move `TR_KEY_primary_mime_type_kebab` handling * refactor: move `TR_KEY_queue_position_camel` handling * refactor: move `TR_KEY_rate_download_camel` handling * refactor: move `TR_KEY_rate_upload_camel` handling * refactor: move `TR_KEY_recheck_progress_camel` handling * refactor: move `TR_KEY_seconds_downloading_camel` handling * refactor: move `TR_KEY_seconds_seeding_camel` handling * refactor: move `TR_KEY_seed_idle_limit_camel` handling * refactor: move `TR_KEY_seed_idle_mode_camel` handling * refactor: move `TR_KEY_seed_ratio_mode_camel` handling * refactor: move `TR_KEY_size_when_done_camel` handling * refactor: move `TR_KEY_start_date_camel` handling * refactor: move `TR_KEY_torrent_file_camel` handling * refactor: move `TR_KEY_total_size_camel` handling * refactor: move `TR_KEY_tracker_list_camel` handling * refactor: move `TR_KEY_tracker_stats_camel` handling * refactor: move `TR_KEY_upload_limit_camel` handling * refactor: move `TR_KEY_upload_limited_camel` handling * refactor: move `TR_KEY_upload_ratio_camel` handling * refactor: move `TR_KEY_uploaded_ever_camel` handling * refactor: move `TR_KEY_webseeds_sending_to_us_camel` handling * refactor: move `TR_KEY_announce_state_camel` handling * refactor: move `TR_KEY_download_count_camel` handling * refactor: move `TR_KEY_has_announced_camel` handling * refactor: move `TR_KEY_has_scraped_camel` handling * refactor: move `TR_KEY_is_backup_camel` handling * refactor: move `TR_KEY_last_announce_peer_count_camel` handling * refactor: move `TR_KEY_last_announce_result_camel` handling * refactor: move `TR_KEY_last_announce_start_time_camel` handling * refactor: move `TR_KEY_last_announce_succeeded_camel` handling * refactor: move `TR_KEY_last_announce_time_camel` handling * refactor: move `TR_KEY_last_announce_timed_out_camel` handling * refactor: move `TR_KEY_last_scrape_result_camel` handling * refactor: move `TR_KEY_last_scrape_start_time_camel` handling * refactor: move `TR_KEY_last_scrape_succeeded_camel` handling * refactor: move `TR_KEY_last_scrape_time_camel` handling * refactor: move `TR_KEY_last_scrape_timed_out_camel` handling * refactor: move `TR_KEY_leecher_count_camel` handling * refactor: move `TR_KEY_next_announce_time_camel` handling * refactor: move `TR_KEY_next_scrape_time_camel` handling * refactor: move `TR_KEY_scrape_state_camel` handling * refactor: move `TR_KEY_seeder_count_camel` handling * refactor: move `TR_KEY_client_is_choked_camel` handling * refactor: move `TR_KEY_client_is_interested_camel` handling * refactor: move `TR_KEY_client_name_camel` handling * refactor: move `TR_KEY_flag_str_camel` handling * refactor: move `TR_KEY_is_downloading_from_camel` handling * refactor: move `TR_KEY_is_encrypted_camel` handling * refactor: move `TR_KEY_is_incoming_camel` handling * refactor: move `TR_KEY_is_utp_camel` handling * refactor: move `TR_KEY_is_uploading_to_camel` handling * refactor: move `TR_KEY_peer_is_choked_camel` handling * refactor: move `TR_KEY_peer_is_interested_camel` handling * refactor: move `TR_KEY_rate_to_client_camel` handling * refactor: move `TR_KEY_rate_to_peer_camel` handling * refactor: move `TR_KEY_from_cache_camel` handling * refactor: move `TR_KEY_from_dht_camel` handling * refactor: move `TR_KEY_from_incoming_camel` handling * refactor: move `TR_KEY_from_lpd_camel` handling * refactor: move `TR_KEY_from_ltep_camel` handling * refactor: move `TR_KEY_from_pex_camel` handling * refactor: move `TR_KEY_from_pex_camel` handling * refactor: move `TR_KEY_tracker_add_camel` handling * refactor: move `TR_KEY_tracker_remove_camel` handling * refactor: move `TR_KEY_tracker_replace_camel` handling * refactor: move `TR_KEY_downloaded_bytes_camel` handling * refactor: move `TR_KEY_files_added_camel` handling * refactor: move `TR_KEY_seconds_active_camel` handling * refactor: move `TR_KEY_session_count_camel` handling * refactor: move `TR_KEY_uploaded_bytes_camel` handling * refactor: move `TR_KEY_active_torrent_count_camel` handling * refactor: move `TR_KEY_cumulative_stats_kebab` handling * refactor: move `TR_KEY_cumulative_stats_kebab` handling * refactor: move `TR_KEY_download_speed_camel` handling * refactor: move `TR_KEY_paused_torrent_count_camel` handling * refactor: move `TR_KEY_torrent_count_camel` handling * refactor: move `TR_KEY_upload_speed_camel` handling * refactor: move `TR_KEY_files_unwanted_kebab` handling * refactor: move `TR_KEY_files_wanted_kebab` handling * refactor: move `TR_KEY_priority_high_kebab` handling * refactor: move `TR_KEY_priority_low_kebab` handling * refactor: move `TR_KEY_priority_normal_kebab` handling * refactor: move `TR_KEY_port_is_open_kebab` handling * refactor: move `TR_KEY_torrent_duplicate_kebab` handling * refactor: move `TR_KEY_torrent_added_kebab` handling * refactor: move `TR_KEY_memory_bytes_kebab` handling * refactor: move `TR_KEY_memory_units_kebab` handling * refactor: move `TR_KEY_size_bytes_kebab` handling * refactor: move `TR_KEY_size_units_kebab` handling * refactor: move `TR_KEY_speed_bytes_kebab` handling * refactor: move `TR_KEY_speed_units_kebab` handling * refactor: remove DoneCb * perf: adjust reserve capacity --- libtransmission/api-compat.cc | 488 ++++++++--------- libtransmission/quark.h | 376 ++++++------- libtransmission/rpcimpl.cc | 658 +++++++---------------- libtransmission/rpcimpl.h | 2 +- libtransmission/session.h | 14 +- qt/RpcClient.cc | 2 +- qt/RpcClient.h | 2 +- tests/libtransmission/api-compat-test.cc | 14 +- tests/libtransmission/rpc-test.cc | 187 +++---- 9 files changed, 716 insertions(+), 1027 deletions(-) diff --git a/libtransmission/api-compat.cc b/libtransmission/api-compat.cc index 17f0ecfed..ba288c5cb 100644 --- a/libtransmission/api-compat.cc +++ b/libtransmission/api-compat.cc @@ -29,194 +29,195 @@ struct ApiKey }; auto constexpr RpcKeys = std::array{ { - { TR_KEY_active_torrent_count, TR_KEY_active_torrent_count_camel }, - { TR_KEY_activity_date, TR_KEY_activity_date_camel }, // TODO(ckerr) legacy duplicate - { TR_KEY_added_date, TR_KEY_added_date_camel }, // TODO(ckerr) legacy duplicate - { TR_KEY_alt_speed_down, TR_KEY_alt_speed_down_kebab }, - { TR_KEY_alt_speed_enabled, TR_KEY_alt_speed_enabled_kebab }, - { TR_KEY_alt_speed_time_begin, TR_KEY_alt_speed_time_begin_kebab }, - { TR_KEY_alt_speed_time_day, TR_KEY_alt_speed_time_day_kebab }, - { TR_KEY_alt_speed_time_enabled, TR_KEY_alt_speed_time_enabled_kebab }, - { TR_KEY_alt_speed_time_end, TR_KEY_alt_speed_time_end_kebab }, - { TR_KEY_alt_speed_up, TR_KEY_alt_speed_up_kebab }, - { TR_KEY_announce_state, TR_KEY_announce_state_camel }, - { TR_KEY_anti_brute_force_enabled, TR_KEY_anti_brute_force_enabled_kebab }, - { TR_KEY_anti_brute_force_threshold, TR_KEY_anti_brute_force_threshold_kebab }, - { TR_KEY_bandwidth_priority, TR_KEY_bandwidth_priority_camel }, // TODO(ckerr) legacy duplicate - { TR_KEY_blocklist_enabled, TR_KEY_blocklist_enabled_kebab }, - { TR_KEY_blocklist_size, TR_KEY_blocklist_size_kebab }, - { TR_KEY_blocklist_url, TR_KEY_blocklist_url_kebab }, - { TR_KEY_bytes_completed, TR_KEY_bytes_completed_camel }, - { TR_KEY_cache_size_mb, TR_KEY_cache_size_mb_kebab }, - { TR_KEY_client_is_choked, TR_KEY_client_is_choked_camel }, - { TR_KEY_client_is_interested, TR_KEY_client_is_interested_camel }, - { TR_KEY_client_name, TR_KEY_client_name_camel }, - { TR_KEY_config_dir, TR_KEY_config_dir_kebab }, - { TR_KEY_corrupt_ever, TR_KEY_corrupt_ever_camel }, - { TR_KEY_cumulative_stats, TR_KEY_cumulative_stats_kebab }, - { TR_KEY_current_stats, TR_KEY_current_stats_kebab }, - { TR_KEY_date_created, TR_KEY_date_created_camel }, - { TR_KEY_default_trackers, TR_KEY_default_trackers_kebab }, - { TR_KEY_delete_local_data, TR_KEY_delete_local_data_kebab }, - { TR_KEY_desired_available, TR_KEY_desired_available_camel }, - { TR_KEY_dht_enabled, TR_KEY_dht_enabled_kebab }, - { TR_KEY_done_date, TR_KEY_done_date_camel }, // TODO(ckerr) legacy duplicate - { TR_KEY_download_count, TR_KEY_download_count_camel }, - { TR_KEY_download_dir, TR_KEY_download_dir_kebab }, // crazy case 1: camel in torrent-get/set, kebab everywhere else - { TR_KEY_download_dir_free_space, TR_KEY_download_dir_free_space_kebab }, - { TR_KEY_download_limit, TR_KEY_download_limit_camel }, - { TR_KEY_download_limited, TR_KEY_download_limited_camel }, - { TR_KEY_download_queue_enabled, TR_KEY_download_queue_enabled_kebab }, - { TR_KEY_download_queue_size, TR_KEY_download_queue_size_kebab }, - { TR_KEY_download_speed, TR_KEY_download_speed_camel }, - { TR_KEY_downloaded_bytes, TR_KEY_downloaded_bytes_camel }, // TODO(ckerr) legacy duplicate - { TR_KEY_downloaded_ever, TR_KEY_downloaded_ever_camel }, - { TR_KEY_edit_date, TR_KEY_edit_date_camel }, - { TR_KEY_error_string, TR_KEY_error_string_camel }, - { TR_KEY_eta_idle, TR_KEY_eta_idle_camel }, - { TR_KEY_file_count, TR_KEY_file_count_kebab }, - { TR_KEY_file_stats, TR_KEY_file_stats_camel }, - { TR_KEY_files_added, TR_KEY_files_added_camel }, // TODO(ckerr) legacy duplicate - { TR_KEY_files_unwanted, TR_KEY_files_unwanted_kebab }, - { TR_KEY_files_wanted, TR_KEY_files_wanted_kebab }, - { TR_KEY_flag_str, TR_KEY_flag_str_camel }, - { TR_KEY_from_cache, TR_KEY_from_cache_camel }, - { TR_KEY_from_dht, TR_KEY_from_dht_camel }, - { TR_KEY_from_incoming, TR_KEY_from_incoming_camel }, - { TR_KEY_from_lpd, TR_KEY_from_lpd_camel }, - { TR_KEY_from_ltep, TR_KEY_from_ltep_camel }, - { TR_KEY_from_pex, TR_KEY_from_pex_camel }, - { TR_KEY_from_tracker, TR_KEY_from_tracker_camel }, - { TR_KEY_has_announced, TR_KEY_has_announced_camel }, - { TR_KEY_has_scraped, TR_KEY_has_scraped_camel }, - { TR_KEY_hash_string, TR_KEY_hash_string_camel }, - { TR_KEY_have_unchecked, TR_KEY_have_unchecked_camel }, - { TR_KEY_have_valid, TR_KEY_have_valid_camel }, - { TR_KEY_honors_session_limits, TR_KEY_honors_session_limits_camel }, - { TR_KEY_idle_seeding_limit, TR_KEY_idle_seeding_limit_kebab }, - { TR_KEY_idle_seeding_limit_enabled, TR_KEY_idle_seeding_limit_enabled_kebab }, - { TR_KEY_incomplete_dir, TR_KEY_incomplete_dir_kebab }, - { TR_KEY_incomplete_dir_enabled, TR_KEY_incomplete_dir_enabled_kebab }, - { TR_KEY_is_backup, TR_KEY_is_backup_camel }, - { TR_KEY_is_downloading_from, TR_KEY_is_downloading_from_camel }, - { TR_KEY_is_encrypted, TR_KEY_is_encrypted_camel }, - { TR_KEY_is_finished, TR_KEY_is_finished_camel }, - { TR_KEY_is_incoming, TR_KEY_is_incoming_camel }, - { TR_KEY_is_private, TR_KEY_is_private_camel }, - { TR_KEY_is_stalled, TR_KEY_is_stalled_camel }, - { TR_KEY_is_uploading_to, TR_KEY_is_uploading_to_camel }, - { TR_KEY_is_utp, TR_KEY_is_utp_camel }, - { TR_KEY_last_announce_peer_count, TR_KEY_last_announce_peer_count_camel }, - { TR_KEY_last_announce_result, TR_KEY_last_announce_result_camel }, - { TR_KEY_last_announce_start_time, TR_KEY_last_announce_start_time_camel }, - { TR_KEY_last_announce_succeeded, TR_KEY_last_announce_succeeded_camel }, - { TR_KEY_last_announce_time, TR_KEY_last_announce_time_camel }, - { TR_KEY_last_announce_timed_out, TR_KEY_last_announce_timed_out_camel }, - { TR_KEY_last_scrape_result, TR_KEY_last_scrape_result_camel }, - { TR_KEY_last_scrape_start_time, TR_KEY_last_scrape_start_time_camel }, - { TR_KEY_last_scrape_succeeded, TR_KEY_last_scrape_succeeded_camel }, - { TR_KEY_last_scrape_time, TR_KEY_last_scrape_time_camel }, - { TR_KEY_last_scrape_timed_out, TR_KEY_last_scrape_timed_out_camel }, - { TR_KEY_leecher_count, TR_KEY_leecher_count_camel }, - { TR_KEY_left_until_done, TR_KEY_left_until_done_camel }, - { TR_KEY_lpd_enabled, TR_KEY_lpd_enabled_kebab }, - { TR_KEY_magnet_link, TR_KEY_magnet_link_camel }, - { TR_KEY_manual_announce_time, TR_KEY_manual_announce_time_camel }, - { TR_KEY_max_connected_peers, TR_KEY_max_connected_peers_camel }, - { TR_KEY_memory_bytes, TR_KEY_memory_bytes_kebab }, - { TR_KEY_memory_units, TR_KEY_memory_units_kebab }, - { TR_KEY_metadata_percent_complete, TR_KEY_metadata_percent_complete_camel }, - { TR_KEY_next_announce_time, TR_KEY_next_announce_time_camel }, - { TR_KEY_next_scrape_time, TR_KEY_next_scrape_time_camel }, - { TR_KEY_paused_torrent_count, TR_KEY_paused_torrent_count_camel }, - { TR_KEY_peer_is_choked, TR_KEY_peer_is_choked_camel }, - { TR_KEY_peer_is_interested, TR_KEY_peer_is_interested_camel }, - { TR_KEY_peer_limit, TR_KEY_peer_limit_kebab }, - { TR_KEY_peer_limit_global, TR_KEY_peer_limit_global_kebab }, - { TR_KEY_peer_limit_per_torrent, TR_KEY_peer_limit_per_torrent_kebab }, - { TR_KEY_peer_port, TR_KEY_peer_port_kebab }, - { TR_KEY_peer_port_random_on_start, TR_KEY_peer_port_random_on_start_kebab }, - { TR_KEY_peers_connected, TR_KEY_peers_connected_camel }, - { TR_KEY_peers_from, TR_KEY_peers_from_camel }, - { TR_KEY_peers_getting_from_us, TR_KEY_peers_getting_from_us_camel }, - { TR_KEY_peers_sending_to_us, TR_KEY_peers_sending_to_us_camel }, - { TR_KEY_percent_complete, TR_KEY_percent_complete_camel }, - { TR_KEY_percent_done, TR_KEY_percent_done_camel }, - { TR_KEY_pex_enabled, TR_KEY_pex_enabled_kebab }, - { TR_KEY_piece_count, TR_KEY_piece_count_camel }, - { TR_KEY_piece_size, TR_KEY_piece_size_camel }, - { TR_KEY_port_forwarding_enabled, TR_KEY_port_forwarding_enabled_kebab }, - { TR_KEY_port_is_open, TR_KEY_port_is_open_kebab }, - { TR_KEY_primary_mime_type, TR_KEY_primary_mime_type_kebab }, - { TR_KEY_priority_high, TR_KEY_priority_high_kebab }, - { TR_KEY_priority_low, TR_KEY_priority_low_kebab }, - { TR_KEY_priority_normal, TR_KEY_priority_normal_kebab }, - { TR_KEY_queue_position, TR_KEY_queue_position_camel }, - { TR_KEY_queue_stalled_enabled, TR_KEY_queue_stalled_enabled_kebab }, - { TR_KEY_queue_stalled_minutes, TR_KEY_queue_stalled_minutes_kebab }, - { TR_KEY_rate_download, TR_KEY_rate_download_camel }, - { TR_KEY_rate_to_client, TR_KEY_rate_to_client_camel }, - { TR_KEY_rate_to_peer, TR_KEY_rate_to_peer_camel }, - { TR_KEY_rate_upload, TR_KEY_rate_upload_camel }, - { TR_KEY_recently_active, TR_KEY_recently_active_kebab }, - { TR_KEY_recheck_progress, TR_KEY_recheck_progress_camel }, - { TR_KEY_rename_partial_files, TR_KEY_rename_partial_files_kebab }, + { TR_KEY_active_torrent_count, TR_KEY_active_torrent_count_camel_APICOMPAT }, + { TR_KEY_activity_date, TR_KEY_activity_date_camel_APICOMPAT }, + { TR_KEY_added_date, TR_KEY_added_date_camel_APICOMPAT }, + { TR_KEY_alt_speed_down, TR_KEY_alt_speed_down_kebab_APICOMPAT }, + { TR_KEY_alt_speed_enabled, TR_KEY_alt_speed_enabled_kebab_APICOMPAT }, + { TR_KEY_alt_speed_time_begin, TR_KEY_alt_speed_time_begin_kebab_APICOMPAT }, + { TR_KEY_alt_speed_time_day, TR_KEY_alt_speed_time_day_kebab_APICOMPAT }, + { TR_KEY_alt_speed_time_enabled, TR_KEY_alt_speed_time_enabled_kebab_APICOMPAT }, + { TR_KEY_alt_speed_time_end, TR_KEY_alt_speed_time_end_kebab_APICOMPAT }, + { TR_KEY_alt_speed_up, TR_KEY_alt_speed_up_kebab_APICOMPAT }, + { TR_KEY_announce_state, TR_KEY_announce_state_camel_APICOMPAT }, + { TR_KEY_anti_brute_force_enabled, TR_KEY_anti_brute_force_enabled_kebab_APICOMPAT }, + { TR_KEY_anti_brute_force_threshold, TR_KEY_anti_brute_force_threshold_kebab_APICOMPAT }, + { TR_KEY_bandwidth_priority, TR_KEY_bandwidth_priority_camel_APICOMPAT }, + { TR_KEY_blocklist_enabled, TR_KEY_blocklist_enabled_kebab_APICOMPAT }, + { TR_KEY_blocklist_size, TR_KEY_blocklist_size_kebab_APICOMPAT }, + { TR_KEY_blocklist_url, TR_KEY_blocklist_url_kebab_APICOMPAT }, + { TR_KEY_bytes_completed, TR_KEY_bytes_completed_camel_APICOMPAT }, + { TR_KEY_cache_size_mb, TR_KEY_cache_size_mb_kebab_APICOMPAT }, + { TR_KEY_client_is_choked, TR_KEY_client_is_choked_camel_APICOMPAT }, + { TR_KEY_client_is_interested, TR_KEY_client_is_interested_camel_APICOMPAT }, + { TR_KEY_client_name, TR_KEY_client_name_camel_APICOMPAT }, + { TR_KEY_config_dir, TR_KEY_config_dir_kebab_APICOMPAT }, + { TR_KEY_corrupt_ever, TR_KEY_corrupt_ever_camel_APICOMPAT }, + { TR_KEY_cumulative_stats, TR_KEY_cumulative_stats_kebab_APICOMPAT }, + { TR_KEY_current_stats, TR_KEY_current_stats_kebab_APICOMPAT }, + { TR_KEY_date_created, TR_KEY_date_created_camel_APICOMPAT }, + { TR_KEY_default_trackers, TR_KEY_default_trackers_kebab_APICOMPAT }, + { TR_KEY_delete_local_data, TR_KEY_delete_local_data_kebab_APICOMPAT }, + { TR_KEY_desired_available, TR_KEY_desired_available_camel_APICOMPAT }, + { TR_KEY_dht_enabled, TR_KEY_dht_enabled_kebab_APICOMPAT }, + { TR_KEY_done_date, TR_KEY_done_date_camel_APICOMPAT }, + { TR_KEY_download_count, TR_KEY_download_count_camel_APICOMPAT }, + { TR_KEY_download_dir, + TR_KEY_download_dir_kebab_APICOMPAT }, // crazy case 1: camel in torrent-get/set, kebab everywhere else + { TR_KEY_download_dir_free_space, TR_KEY_download_dir_free_space_kebab_APICOMPAT }, + { TR_KEY_download_limit, TR_KEY_download_limit_camel_APICOMPAT }, + { TR_KEY_download_limited, TR_KEY_download_limited_camel_APICOMPAT }, + { TR_KEY_download_queue_enabled, TR_KEY_download_queue_enabled_kebab_APICOMPAT }, + { TR_KEY_download_queue_size, TR_KEY_download_queue_size_kebab_APICOMPAT }, + { TR_KEY_download_speed, TR_KEY_download_speed_camel_APICOMPAT }, + { TR_KEY_downloaded_bytes, TR_KEY_downloaded_bytes_camel_APICOMPAT }, + { TR_KEY_downloaded_ever, TR_KEY_downloaded_ever_camel_APICOMPAT }, + { TR_KEY_edit_date, TR_KEY_edit_date_camel_APICOMPAT }, + { TR_KEY_error_string, TR_KEY_error_string_camel_APICOMPAT }, + { TR_KEY_eta_idle, TR_KEY_eta_idle_camel_APICOMPAT }, + { TR_KEY_file_count, TR_KEY_file_count_kebab_APICOMPAT }, + { TR_KEY_file_stats, TR_KEY_file_stats_camel_APICOMPAT }, + { TR_KEY_files_added, TR_KEY_files_added_camel_APICOMPAT }, + { TR_KEY_files_unwanted, TR_KEY_files_unwanted_kebab_APICOMPAT }, + { TR_KEY_files_wanted, TR_KEY_files_wanted_kebab_APICOMPAT }, + { TR_KEY_flag_str, TR_KEY_flag_str_camel_APICOMPAT }, + { TR_KEY_from_cache, TR_KEY_from_cache_camel_APICOMPAT }, + { TR_KEY_from_dht, TR_KEY_from_dht_camel_APICOMPAT }, + { TR_KEY_from_incoming, TR_KEY_from_incoming_camel_APICOMPAT }, + { TR_KEY_from_lpd, TR_KEY_from_lpd_camel_APICOMPAT }, + { TR_KEY_from_ltep, TR_KEY_from_ltep_camel_APICOMPAT }, + { TR_KEY_from_pex, TR_KEY_from_pex_camel_APICOMPAT }, + { TR_KEY_from_tracker, TR_KEY_from_tracker_camel_APICOMPAT }, + { TR_KEY_has_announced, TR_KEY_has_announced_camel_APICOMPAT }, + { TR_KEY_has_scraped, TR_KEY_has_scraped_camel_APICOMPAT }, + { TR_KEY_hash_string, TR_KEY_hash_string_camel_APICOMPAT }, + { TR_KEY_have_unchecked, TR_KEY_have_unchecked_camel_APICOMPAT }, + { TR_KEY_have_valid, TR_KEY_have_valid_camel_APICOMPAT }, + { TR_KEY_honors_session_limits, TR_KEY_honors_session_limits_camel_APICOMPAT }, + { TR_KEY_idle_seeding_limit, TR_KEY_idle_seeding_limit_kebab_APICOMPAT }, + { TR_KEY_idle_seeding_limit_enabled, TR_KEY_idle_seeding_limit_enabled_kebab_APICOMPAT }, + { TR_KEY_incomplete_dir, TR_KEY_incomplete_dir_kebab_APICOMPAT }, + { TR_KEY_incomplete_dir_enabled, TR_KEY_incomplete_dir_enabled_kebab_APICOMPAT }, + { TR_KEY_is_backup, TR_KEY_is_backup_camel_APICOMPAT }, + { TR_KEY_is_downloading_from, TR_KEY_is_downloading_from_camel_APICOMPAT }, + { TR_KEY_is_encrypted, TR_KEY_is_encrypted_camel_APICOMPAT }, + { TR_KEY_is_finished, TR_KEY_is_finished_camel_APICOMPAT }, + { TR_KEY_is_incoming, TR_KEY_is_incoming_camel_APICOMPAT }, + { TR_KEY_is_private, TR_KEY_is_private_camel_APICOMPAT }, + { TR_KEY_is_stalled, TR_KEY_is_stalled_camel_APICOMPAT }, + { TR_KEY_is_uploading_to, TR_KEY_is_uploading_to_camel_APICOMPAT }, + { TR_KEY_is_utp, TR_KEY_is_utp_camel_APICOMPAT }, + { TR_KEY_last_announce_peer_count, TR_KEY_last_announce_peer_count_camel_APICOMPAT }, + { TR_KEY_last_announce_result, TR_KEY_last_announce_result_camel_APICOMPAT }, + { TR_KEY_last_announce_start_time, TR_KEY_last_announce_start_time_camel_APICOMPAT }, + { TR_KEY_last_announce_succeeded, TR_KEY_last_announce_succeeded_camel_APICOMPAT }, + { TR_KEY_last_announce_time, TR_KEY_last_announce_time_camel_APICOMPAT }, + { TR_KEY_last_announce_timed_out, TR_KEY_last_announce_timed_out_camel_APICOMPAT }, + { TR_KEY_last_scrape_result, TR_KEY_last_scrape_result_camel_APICOMPAT }, + { TR_KEY_last_scrape_start_time, TR_KEY_last_scrape_start_time_camel_APICOMPAT }, + { TR_KEY_last_scrape_succeeded, TR_KEY_last_scrape_succeeded_camel_APICOMPAT }, + { TR_KEY_last_scrape_time, TR_KEY_last_scrape_time_camel_APICOMPAT }, + { TR_KEY_last_scrape_timed_out, TR_KEY_last_scrape_timed_out_camel_APICOMPAT }, + { TR_KEY_leecher_count, TR_KEY_leecher_count_camel_APICOMPAT }, + { TR_KEY_left_until_done, TR_KEY_left_until_done_camel_APICOMPAT }, + { TR_KEY_lpd_enabled, TR_KEY_lpd_enabled_kebab_APICOMPAT }, + { TR_KEY_magnet_link, TR_KEY_magnet_link_camel_APICOMPAT }, + { TR_KEY_manual_announce_time, TR_KEY_manual_announce_time_camel_APICOMPAT }, + { TR_KEY_max_connected_peers, TR_KEY_max_connected_peers_camel_APICOMPAT }, + { TR_KEY_memory_bytes, TR_KEY_memory_bytes_kebab_APICOMPAT }, + { TR_KEY_memory_units, TR_KEY_memory_units_kebab_APICOMPAT }, + { TR_KEY_metadata_percent_complete, TR_KEY_metadata_percent_complete_camel_APICOMPAT }, + { TR_KEY_next_announce_time, TR_KEY_next_announce_time_camel_APICOMPAT }, + { TR_KEY_next_scrape_time, TR_KEY_next_scrape_time_camel_APICOMPAT }, + { TR_KEY_paused_torrent_count, TR_KEY_paused_torrent_count_camel_APICOMPAT }, + { TR_KEY_peer_is_choked, TR_KEY_peer_is_choked_camel_APICOMPAT }, + { TR_KEY_peer_is_interested, TR_KEY_peer_is_interested_camel_APICOMPAT }, + { TR_KEY_peer_limit, TR_KEY_peer_limit_kebab_APICOMPAT }, + { TR_KEY_peer_limit_global, TR_KEY_peer_limit_global_kebab_APICOMPAT }, + { TR_KEY_peer_limit_per_torrent, TR_KEY_peer_limit_per_torrent_kebab_APICOMPAT }, + { TR_KEY_peer_port, TR_KEY_peer_port_kebab_APICOMPAT }, + { TR_KEY_peer_port_random_on_start, TR_KEY_peer_port_random_on_start_kebab_APICOMPAT }, + { TR_KEY_peers_connected, TR_KEY_peers_connected_camel_APICOMPAT }, + { TR_KEY_peers_from, TR_KEY_peers_from_camel_APICOMPAT }, + { TR_KEY_peers_getting_from_us, TR_KEY_peers_getting_from_us_camel_APICOMPAT }, + { TR_KEY_peers_sending_to_us, TR_KEY_peers_sending_to_us_camel_APICOMPAT }, + { TR_KEY_percent_complete, TR_KEY_percent_complete_camel_APICOMPAT }, + { TR_KEY_percent_done, TR_KEY_percent_done_camel_APICOMPAT }, + { TR_KEY_pex_enabled, TR_KEY_pex_enabled_kebab_APICOMPAT }, + { TR_KEY_piece_count, TR_KEY_piece_count_camel_APICOMPAT }, + { TR_KEY_piece_size, TR_KEY_piece_size_camel_APICOMPAT }, + { TR_KEY_port_forwarding_enabled, TR_KEY_port_forwarding_enabled_kebab_APICOMPAT }, + { TR_KEY_port_is_open, TR_KEY_port_is_open_kebab_APICOMPAT }, + { TR_KEY_primary_mime_type, TR_KEY_primary_mime_type_kebab_APICOMPAT }, + { TR_KEY_priority_high, TR_KEY_priority_high_kebab_APICOMPAT }, + { TR_KEY_priority_low, TR_KEY_priority_low_kebab_APICOMPAT }, + { TR_KEY_priority_normal, TR_KEY_priority_normal_kebab_APICOMPAT }, + { TR_KEY_queue_position, TR_KEY_queue_position_camel_APICOMPAT }, + { TR_KEY_queue_stalled_enabled, TR_KEY_queue_stalled_enabled_kebab_APICOMPAT }, + { TR_KEY_queue_stalled_minutes, TR_KEY_queue_stalled_minutes_kebab_APICOMPAT }, + { TR_KEY_rate_download, TR_KEY_rate_download_camel_APICOMPAT }, + { TR_KEY_rate_to_client, TR_KEY_rate_to_client_camel_APICOMPAT }, + { TR_KEY_rate_to_peer, TR_KEY_rate_to_peer_camel_APICOMPAT }, + { TR_KEY_rate_upload, TR_KEY_rate_upload_camel_APICOMPAT }, + { TR_KEY_recently_active, TR_KEY_recently_active_kebab_APICOMPAT }, + { TR_KEY_recheck_progress, TR_KEY_recheck_progress_camel_APICOMPAT }, + { TR_KEY_rename_partial_files, TR_KEY_rename_partial_files_kebab_APICOMPAT }, { TR_KEY_rpc_host_whitelist, TR_KEY_rpc_host_whitelist_kebab }, { TR_KEY_rpc_host_whitelist_enabled, TR_KEY_rpc_host_whitelist_enabled_kebab }, - { TR_KEY_rpc_version, TR_KEY_rpc_version_kebab }, - { TR_KEY_rpc_version_minimum, TR_KEY_rpc_version_minimum_kebab }, - { TR_KEY_rpc_version_semver, TR_KEY_rpc_version_semver_kebab }, - { TR_KEY_scrape_state, TR_KEY_scrape_state_camel }, - { TR_KEY_script_torrent_added_enabled, TR_KEY_script_torrent_added_enabled_kebab }, - { TR_KEY_script_torrent_added_filename, TR_KEY_script_torrent_added_filename_kebab }, - { TR_KEY_script_torrent_done_enabled, TR_KEY_script_torrent_done_enabled_kebab }, - { TR_KEY_script_torrent_done_filename, TR_KEY_script_torrent_done_filename_kebab }, - { TR_KEY_script_torrent_done_seeding_enabled, TR_KEY_script_torrent_done_seeding_enabled_kebab }, - { TR_KEY_script_torrent_done_seeding_filename, TR_KEY_script_torrent_done_seeding_filename_kebab }, - { TR_KEY_seconds_active, TR_KEY_seconds_active_camel }, // TODO(ckerr) legacy duplicate - { TR_KEY_seconds_downloading, TR_KEY_seconds_downloading_camel }, - { TR_KEY_seconds_seeding, TR_KEY_seconds_seeding_camel }, - { TR_KEY_seed_idle_limit, TR_KEY_seed_idle_limit_camel }, - { TR_KEY_seed_idle_mode, TR_KEY_seed_idle_mode_camel }, - { TR_KEY_seed_queue_enabled, TR_KEY_seed_queue_enabled_kebab }, - { TR_KEY_seed_queue_size, TR_KEY_seed_queue_size_kebab }, - { TR_KEY_seed_ratio_limit, TR_KEY_seed_ratio_limit_camel }, - { TR_KEY_seed_ratio_limited, TR_KEY_seed_ratio_limited_camel }, - { TR_KEY_seed_ratio_mode, TR_KEY_seed_ratio_mode_camel }, - { TR_KEY_seeder_count, TR_KEY_seeder_count_camel }, - { TR_KEY_session_count, TR_KEY_session_count_camel }, // TODO(ckerr) legacy duplicate - { TR_KEY_session_id, TR_KEY_session_id_kebab }, - { TR_KEY_size_bytes, TR_KEY_size_bytes_kebab }, - { TR_KEY_size_units, TR_KEY_size_units_kebab }, - { TR_KEY_size_when_done, TR_KEY_size_when_done_camel }, - { TR_KEY_speed_bytes, TR_KEY_speed_bytes_kebab }, - { TR_KEY_speed_limit_down, TR_KEY_speed_limit_down_kebab }, - { TR_KEY_speed_limit_down_enabled, TR_KEY_speed_limit_down_enabled_kebab }, - { TR_KEY_speed_limit_up, TR_KEY_speed_limit_up_kebab }, - { TR_KEY_speed_limit_up_enabled, TR_KEY_speed_limit_up_enabled_kebab }, - { TR_KEY_speed_units, TR_KEY_speed_units_kebab }, - { TR_KEY_start_added_torrents, TR_KEY_start_added_torrents_kebab }, - { TR_KEY_start_date, TR_KEY_start_date_camel }, - { TR_KEY_tcp_enabled, TR_KEY_tcp_enabled_kebab }, - { TR_KEY_torrent_added, TR_KEY_torrent_added_kebab }, - { TR_KEY_torrent_count, TR_KEY_torrent_count_camel }, - { TR_KEY_torrent_duplicate, TR_KEY_torrent_duplicate_kebab }, - { TR_KEY_torrent_file, TR_KEY_torrent_file_camel }, - { TR_KEY_total_size, TR_KEY_total_size_camel }, - { TR_KEY_tracker_add, TR_KEY_tracker_add_camel }, - { TR_KEY_tracker_list, TR_KEY_tracker_list_camel }, - { TR_KEY_tracker_remove, TR_KEY_tracker_remove_camel }, - { TR_KEY_tracker_replace, TR_KEY_tracker_replace_camel }, - { TR_KEY_tracker_stats, TR_KEY_tracker_stats_camel }, - { TR_KEY_trash_original_torrent_files, TR_KEY_trash_original_torrent_files_kebab }, - { TR_KEY_upload_limit, TR_KEY_upload_limit_camel }, - { TR_KEY_upload_limited, TR_KEY_upload_limited_camel }, - { TR_KEY_upload_ratio, TR_KEY_upload_ratio_camel }, - { TR_KEY_upload_speed, TR_KEY_upload_speed_camel }, - { TR_KEY_uploaded_bytes, TR_KEY_uploaded_bytes_camel }, // TODO(ckerr) legacy duplicate - { TR_KEY_uploaded_ever, TR_KEY_uploaded_ever_camel }, - { TR_KEY_utp_enabled, TR_KEY_utp_enabled_kebab }, - { TR_KEY_webseeds_sending_to_us, TR_KEY_webseeds_sending_to_us_camel }, + { TR_KEY_rpc_version, TR_KEY_rpc_version_kebab_APICOMPAT }, + { TR_KEY_rpc_version_minimum, TR_KEY_rpc_version_minimum_kebab_APICOMPAT }, + { TR_KEY_rpc_version_semver, TR_KEY_rpc_version_semver_kebab_APICOMPAT }, + { TR_KEY_scrape_state, TR_KEY_scrape_state_camel_APICOMPAT }, + { TR_KEY_script_torrent_added_enabled, TR_KEY_script_torrent_added_enabled_kebab_APICOMPAT }, + { TR_KEY_script_torrent_added_filename, TR_KEY_script_torrent_added_filename_kebab_APICOMPAT }, + { TR_KEY_script_torrent_done_enabled, TR_KEY_script_torrent_done_enabled_kebab_APICOMPAT }, + { TR_KEY_script_torrent_done_filename, TR_KEY_script_torrent_done_filename_kebab_APICOMPAT }, + { TR_KEY_script_torrent_done_seeding_enabled, TR_KEY_script_torrent_done_seeding_enabled_kebab_APICOMPAT }, + { TR_KEY_script_torrent_done_seeding_filename, TR_KEY_script_torrent_done_seeding_filename_kebab_APICOMPAT }, + { TR_KEY_seconds_active, TR_KEY_seconds_active_camel_APICOMPAT }, + { TR_KEY_seconds_downloading, TR_KEY_seconds_downloading_camel_APICOMPAT }, + { TR_KEY_seconds_seeding, TR_KEY_seconds_seeding_camel_APICOMPAT }, + { TR_KEY_seed_idle_limit, TR_KEY_seed_idle_limit_camel_APICOMPAT }, + { TR_KEY_seed_idle_mode, TR_KEY_seed_idle_mode_camel_APICOMPAT }, + { TR_KEY_seed_queue_enabled, TR_KEY_seed_queue_enabled_kebab_APICOMPAT }, + { TR_KEY_seed_queue_size, TR_KEY_seed_queue_size_kebab_APICOMPAT }, + { TR_KEY_seed_ratio_limit, TR_KEY_seed_ratio_limit_camel_APICOMPAT }, + { TR_KEY_seed_ratio_limited, TR_KEY_seed_ratio_limited_camel_APICOMPAT }, + { TR_KEY_seed_ratio_mode, TR_KEY_seed_ratio_mode_camel_APICOMPAT }, + { TR_KEY_seeder_count, TR_KEY_seeder_count_camel_APICOMPAT }, + { TR_KEY_session_count, TR_KEY_session_count_camel_APICOMPAT }, + { TR_KEY_session_id, TR_KEY_session_id_kebab_APICOMPAT }, + { TR_KEY_size_bytes, TR_KEY_size_bytes_kebab_APICOMPAT }, + { TR_KEY_size_units, TR_KEY_size_units_kebab_APICOMPAT }, + { TR_KEY_size_when_done, TR_KEY_size_when_done_camel_APICOMPAT }, + { TR_KEY_speed_bytes, TR_KEY_speed_bytes_kebab_APICOMPAT }, + { TR_KEY_speed_limit_down, TR_KEY_speed_limit_down_kebab_APICOMPAT }, + { TR_KEY_speed_limit_down_enabled, TR_KEY_speed_limit_down_enabled_kebab_APICOMPAT }, + { TR_KEY_speed_limit_up, TR_KEY_speed_limit_up_kebab_APICOMPAT }, + { TR_KEY_speed_limit_up_enabled, TR_KEY_speed_limit_up_enabled_kebab_APICOMPAT }, + { TR_KEY_speed_units, TR_KEY_speed_units_kebab_APICOMPAT }, + { TR_KEY_start_added_torrents, TR_KEY_start_added_torrents_kebab_APICOMPAT }, + { TR_KEY_start_date, TR_KEY_start_date_camel_APICOMPAT }, + { TR_KEY_tcp_enabled, TR_KEY_tcp_enabled_kebab_APICOMPAT }, + { TR_KEY_torrent_added, TR_KEY_torrent_added_kebab_APICOMPAT }, + { TR_KEY_torrent_count, TR_KEY_torrent_count_camel_APICOMPAT }, + { TR_KEY_torrent_duplicate, TR_KEY_torrent_duplicate_kebab_APICOMPAT }, + { TR_KEY_torrent_file, TR_KEY_torrent_file_camel_APICOMPAT }, + { TR_KEY_total_size, TR_KEY_total_size_camel_APICOMPAT }, + { TR_KEY_tracker_add, TR_KEY_tracker_add_camel_APICOMPAT }, + { TR_KEY_tracker_list, TR_KEY_tracker_list_camel_APICOMPAT }, + { TR_KEY_tracker_remove, TR_KEY_tracker_remove_camel_APICOMPAT }, + { TR_KEY_tracker_replace, TR_KEY_tracker_replace_camel_APICOMPAT }, + { TR_KEY_tracker_stats, TR_KEY_tracker_stats_camel_APICOMPAT }, + { TR_KEY_trash_original_torrent_files, TR_KEY_trash_original_torrent_files_kebab_APICOMPAT }, + { TR_KEY_upload_limit, TR_KEY_upload_limit_camel_APICOMPAT }, + { TR_KEY_upload_limited, TR_KEY_upload_limited_camel_APICOMPAT }, + { TR_KEY_upload_ratio, TR_KEY_upload_ratio_camel_APICOMPAT }, + { TR_KEY_upload_speed, TR_KEY_upload_speed_camel_APICOMPAT }, + { TR_KEY_uploaded_bytes, TR_KEY_uploaded_bytes_camel_APICOMPAT }, + { TR_KEY_uploaded_ever, TR_KEY_uploaded_ever_camel_APICOMPAT }, + { TR_KEY_utp_enabled, TR_KEY_utp_enabled_kebab_APICOMPAT }, + { TR_KEY_webseeds_sending_to_us, TR_KEY_webseeds_sending_to_us_camel_APICOMPAT }, { TR_KEY_blocklist_update, TR_KEY_blocklist_update_kebab }, { TR_KEY_free_space, TR_KEY_free_space_kebab }, { TR_KEY_group_get, TR_KEY_group_get_kebab }, @@ -246,34 +247,34 @@ auto constexpr RpcKeys = std::array{ { auto constexpr SessionKeys = std::array{ { { TR_KEY_activity_date, TR_KEY_activity_date_kebab_APICOMPAT }, { TR_KEY_added_date, TR_KEY_added_date_kebab_APICOMPAT }, - { TR_KEY_alt_speed_down, TR_KEY_alt_speed_down_kebab }, - { TR_KEY_alt_speed_enabled, TR_KEY_alt_speed_enabled_kebab }, - { TR_KEY_alt_speed_time_begin, TR_KEY_alt_speed_time_begin_kebab }, - { TR_KEY_alt_speed_time_day, TR_KEY_alt_speed_time_day_kebab }, - { TR_KEY_alt_speed_time_enabled, TR_KEY_alt_speed_time_enabled_kebab }, - { TR_KEY_alt_speed_time_end, TR_KEY_alt_speed_time_end_kebab }, - { TR_KEY_alt_speed_up, TR_KEY_alt_speed_up_kebab }, + { TR_KEY_alt_speed_down, TR_KEY_alt_speed_down_kebab_APICOMPAT }, + { TR_KEY_alt_speed_enabled, TR_KEY_alt_speed_enabled_kebab_APICOMPAT }, + { TR_KEY_alt_speed_time_begin, TR_KEY_alt_speed_time_begin_kebab_APICOMPAT }, + { TR_KEY_alt_speed_time_day, TR_KEY_alt_speed_time_day_kebab_APICOMPAT }, + { TR_KEY_alt_speed_time_enabled, TR_KEY_alt_speed_time_enabled_kebab_APICOMPAT }, + { TR_KEY_alt_speed_time_end, TR_KEY_alt_speed_time_end_kebab_APICOMPAT }, + { TR_KEY_alt_speed_up, TR_KEY_alt_speed_up_kebab_APICOMPAT }, { TR_KEY_announce_ip, TR_KEY_announce_ip_kebab }, { TR_KEY_announce_ip_enabled, TR_KEY_announce_ip_enabled_kebab }, - { TR_KEY_anti_brute_force_enabled, TR_KEY_anti_brute_force_enabled_kebab }, - { TR_KEY_anti_brute_force_threshold, TR_KEY_anti_brute_force_threshold_kebab }, + { TR_KEY_anti_brute_force_enabled, TR_KEY_anti_brute_force_enabled_kebab_APICOMPAT }, + { TR_KEY_anti_brute_force_threshold, TR_KEY_anti_brute_force_threshold_kebab_APICOMPAT }, { TR_KEY_bandwidth_priority, TR_KEY_bandwidth_priority_kebab_APICOMPAT }, { TR_KEY_bind_address_ipv4, TR_KEY_bind_address_ipv4_kebab }, { TR_KEY_bind_address_ipv6, TR_KEY_bind_address_ipv6_kebab }, { TR_KEY_blocklist_date, TR_KEY_blocklist_date_kebab }, - { TR_KEY_blocklist_enabled, TR_KEY_blocklist_enabled_kebab }, + { TR_KEY_blocklist_enabled, TR_KEY_blocklist_enabled_kebab_APICOMPAT }, { TR_KEY_blocklist_updates_enabled, TR_KEY_blocklist_updates_enabled_kebab }, - { TR_KEY_blocklist_url, TR_KEY_blocklist_url_kebab }, - { TR_KEY_cache_size_mb, TR_KEY_cache_size_mb_kebab }, + { TR_KEY_blocklist_url, TR_KEY_blocklist_url_kebab_APICOMPAT }, + { TR_KEY_cache_size_mb, TR_KEY_cache_size_mb_kebab_APICOMPAT }, { TR_KEY_compact_view, TR_KEY_compact_view_kebab }, - { TR_KEY_default_trackers, TR_KEY_default_trackers_kebab }, + { TR_KEY_default_trackers, TR_KEY_default_trackers_kebab_APICOMPAT }, { TR_KEY_details_window_height, TR_KEY_details_window_height_kebab }, { TR_KEY_details_window_width, TR_KEY_details_window_width_kebab }, - { TR_KEY_dht_enabled, TR_KEY_dht_enabled_kebab }, + { TR_KEY_dht_enabled, TR_KEY_dht_enabled_kebab_APICOMPAT }, { TR_KEY_done_date, TR_KEY_done_date_kebab_APICOMPAT }, - { TR_KEY_download_dir, TR_KEY_download_dir_kebab }, // TODO(ckerr) legacy duplicate - { TR_KEY_download_queue_enabled, TR_KEY_download_queue_enabled_kebab }, - { TR_KEY_download_queue_size, TR_KEY_download_queue_size_kebab }, + { TR_KEY_download_dir, TR_KEY_download_dir_kebab_APICOMPAT }, + { TR_KEY_download_queue_enabled, TR_KEY_download_queue_enabled_kebab_APICOMPAT }, + { TR_KEY_download_queue_size, TR_KEY_download_queue_size_kebab_APICOMPAT }, { TR_KEY_downloaded_bytes, TR_KEY_downloaded_bytes_kebab_APICOMPAT }, { TR_KEY_downloading_time_seconds, TR_KEY_downloading_time_seconds_kebab_APICOMPAT }, { TR_KEY_files_added, TR_KEY_files_added_kebab_APICOMPAT }, @@ -282,12 +283,12 @@ auto constexpr SessionKeys = std::array{ { { TR_KEY_filter_trackers, TR_KEY_filter_trackers_kebab }, { TR_KEY_idle_limit, TR_KEY_idle_limit_kebab_APICOMPAT }, { TR_KEY_idle_mode, TR_KEY_idle_mode_kebab_APICOMPAT }, - { TR_KEY_idle_seeding_limit, TR_KEY_idle_seeding_limit_kebab }, - { TR_KEY_idle_seeding_limit_enabled, TR_KEY_idle_seeding_limit_enabled_kebab }, - { TR_KEY_incomplete_dir, TR_KEY_incomplete_dir_kebab }, - { TR_KEY_incomplete_dir_enabled, TR_KEY_incomplete_dir_enabled_kebab }, + { TR_KEY_idle_seeding_limit, TR_KEY_idle_seeding_limit_kebab_APICOMPAT }, + { TR_KEY_idle_seeding_limit_enabled, TR_KEY_idle_seeding_limit_enabled_kebab_APICOMPAT }, + { TR_KEY_incomplete_dir, TR_KEY_incomplete_dir_kebab_APICOMPAT }, + { TR_KEY_incomplete_dir_enabled, TR_KEY_incomplete_dir_enabled_kebab_APICOMPAT }, { TR_KEY_inhibit_desktop_hibernation, TR_KEY_inhibit_desktop_hibernation_kebab }, - { TR_KEY_lpd_enabled, TR_KEY_lpd_enabled_kebab }, + { TR_KEY_lpd_enabled, TR_KEY_lpd_enabled_kebab_APICOMPAT }, { TR_KEY_main_window_height, TR_KEY_main_window_height_kebab }, { TR_KEY_main_window_is_maximized, TR_KEY_main_window_is_maximized_kebab }, { TR_KEY_main_window_layout_order, TR_KEY_main_window_layout_order_kebab }, @@ -298,19 +299,19 @@ auto constexpr SessionKeys = std::array{ { { TR_KEY_message_level, TR_KEY_message_level_kebab }, { TR_KEY_open_dialog_dir, TR_KEY_open_dialog_dir_kebab }, { TR_KEY_peer_congestion_algorithm, TR_KEY_peer_congestion_algorithm_kebab }, - { TR_KEY_peer_limit_global, TR_KEY_peer_limit_global_kebab }, - { TR_KEY_peer_limit_per_torrent, TR_KEY_peer_limit_per_torrent_kebab }, - { TR_KEY_peer_port, TR_KEY_peer_port_kebab }, + { TR_KEY_peer_limit_global, TR_KEY_peer_limit_global_kebab_APICOMPAT }, + { TR_KEY_peer_limit_per_torrent, TR_KEY_peer_limit_per_torrent_kebab_APICOMPAT }, + { TR_KEY_peer_port, TR_KEY_peer_port_kebab_APICOMPAT }, { TR_KEY_peer_port_random_high, TR_KEY_peer_port_random_high_kebab }, { TR_KEY_peer_port_random_low, TR_KEY_peer_port_random_low_kebab }, - { TR_KEY_peer_port_random_on_start, TR_KEY_peer_port_random_on_start_kebab }, + { TR_KEY_peer_port_random_on_start, TR_KEY_peer_port_random_on_start_kebab_APICOMPAT }, { TR_KEY_peer_socket_tos, TR_KEY_peer_socket_tos_kebab }, { TR_KEY_peers2_6, TR_KEY_peers2_6_kebab_APICOMPAT }, - { TR_KEY_pex_enabled, TR_KEY_pex_enabled_kebab }, - { TR_KEY_port_forwarding_enabled, TR_KEY_port_forwarding_enabled_kebab }, + { TR_KEY_pex_enabled, TR_KEY_pex_enabled_kebab_APICOMPAT }, + { TR_KEY_port_forwarding_enabled, TR_KEY_port_forwarding_enabled_kebab_APICOMPAT }, { TR_KEY_prompt_before_exit, TR_KEY_prompt_before_exit_kebab }, - { TR_KEY_queue_stalled_enabled, TR_KEY_queue_stalled_enabled_kebab }, - { TR_KEY_queue_stalled_minutes, TR_KEY_queue_stalled_minutes_kebab }, + { TR_KEY_queue_stalled_enabled, TR_KEY_queue_stalled_enabled_kebab_APICOMPAT }, + { TR_KEY_queue_stalled_minutes, TR_KEY_queue_stalled_minutes_kebab_APICOMPAT }, { TR_KEY_ratio_limit, TR_KEY_ratio_limit_kebab }, { TR_KEY_ratio_limit_enabled, TR_KEY_ratio_limit_enabled_kebab }, { TR_KEY_ratio_mode, TR_KEY_ratio_mode_kebab_APICOMPAT }, @@ -322,7 +323,7 @@ auto constexpr SessionKeys = std::array{ { { TR_KEY_remote_session_port, TR_KEY_remote_session_port_kebab }, { TR_KEY_remote_session_requires_authentication, TR_KEY_remote_session_requres_authentication_kebab }, { TR_KEY_remote_session_username, TR_KEY_remote_session_username_kebab }, - { TR_KEY_rename_partial_files, TR_KEY_rename_partial_files_kebab }, + { TR_KEY_rename_partial_files, TR_KEY_rename_partial_files_kebab_APICOMPAT }, { TR_KEY_rpc_authentication_required, TR_KEY_rpc_authentication_required_kebab }, { TR_KEY_rpc_bind_address, TR_KEY_rpc_bind_address_kebab }, { TR_KEY_rpc_enabled, TR_KEY_rpc_enabled_kebab }, @@ -336,15 +337,15 @@ auto constexpr SessionKeys = std::array{ { { TR_KEY_rpc_whitelist, TR_KEY_rpc_whitelist_kebab }, { TR_KEY_rpc_whitelist_enabled, TR_KEY_rpc_whitelist_enabled_kebab }, { TR_KEY_scrape_paused_torrents_enabled, TR_KEY_scrape_paused_torrents_enabled_kebab }, - { TR_KEY_script_torrent_added_enabled, TR_KEY_script_torrent_added_enabled_kebab }, - { TR_KEY_script_torrent_added_filename, TR_KEY_script_torrent_added_filename_kebab }, - { TR_KEY_script_torrent_done_enabled, TR_KEY_script_torrent_done_enabled_kebab }, - { TR_KEY_script_torrent_done_filename, TR_KEY_script_torrent_done_filename_kebab }, - { TR_KEY_script_torrent_done_seeding_enabled, TR_KEY_script_torrent_done_seeding_enabled_kebab }, - { TR_KEY_script_torrent_done_seeding_filename, TR_KEY_script_torrent_done_seeding_filename_kebab }, + { TR_KEY_script_torrent_added_enabled, TR_KEY_script_torrent_added_enabled_kebab_APICOMPAT }, + { TR_KEY_script_torrent_added_filename, TR_KEY_script_torrent_added_filename_kebab_APICOMPAT }, + { TR_KEY_script_torrent_done_enabled, TR_KEY_script_torrent_done_enabled_kebab_APICOMPAT }, + { TR_KEY_script_torrent_done_filename, TR_KEY_script_torrent_done_filename_kebab_APICOMPAT }, + { TR_KEY_script_torrent_done_seeding_enabled, TR_KEY_script_torrent_done_seeding_enabled_kebab_APICOMPAT }, + { TR_KEY_script_torrent_done_seeding_filename, TR_KEY_script_torrent_done_seeding_filename_kebab_APICOMPAT }, { TR_KEY_seconds_active, TR_KEY_seconds_active_kebab_APICOMPAT }, - { TR_KEY_seed_queue_enabled, TR_KEY_seed_queue_enabled_kebab }, - { TR_KEY_seed_queue_size, TR_KEY_seed_queue_size_kebab }, + { TR_KEY_seed_queue_enabled, TR_KEY_seed_queue_enabled_kebab_APICOMPAT }, + { TR_KEY_seed_queue_size, TR_KEY_seed_queue_size_kebab_APICOMPAT }, { TR_KEY_seeding_time_seconds, TR_KEY_seeding_time_seconds_kebab_APICOMPAT }, { TR_KEY_session_count, TR_KEY_session_count_kebab_APICOMPAT }, { TR_KEY_show_active, TR_KEY_show_active_kebab_APICOMPAT }, @@ -377,14 +378,14 @@ auto constexpr SessionKeys = std::array{ { { TR_KEY_sort_mode, TR_KEY_sort_mode_kebab }, { TR_KEY_sort_reversed, TR_KEY_sort_reversed_kebab }, { TR_KEY_speed_Bps, TR_KEY_speed_Bps_kebab_APICOMPAT }, - { TR_KEY_speed_limit_down, TR_KEY_speed_limit_down_kebab }, - { TR_KEY_speed_limit_down_enabled, TR_KEY_speed_limit_down_enabled_kebab }, - { TR_KEY_speed_limit_up, TR_KEY_speed_limit_up_kebab }, - { TR_KEY_speed_limit_up_enabled, TR_KEY_speed_limit_up_enabled_kebab }, - { TR_KEY_start_added_torrents, TR_KEY_start_added_torrents_kebab }, + { TR_KEY_speed_limit_down, TR_KEY_speed_limit_down_kebab_APICOMPAT }, + { TR_KEY_speed_limit_down_enabled, TR_KEY_speed_limit_down_enabled_kebab_APICOMPAT }, + { TR_KEY_speed_limit_up, TR_KEY_speed_limit_up_kebab_APICOMPAT }, + { TR_KEY_speed_limit_up_enabled, TR_KEY_speed_limit_up_enabled_kebab_APICOMPAT }, + { TR_KEY_start_added_torrents, TR_KEY_start_added_torrents_kebab_APICOMPAT }, { TR_KEY_start_minimized, TR_KEY_start_minimized_kebab }, { TR_KEY_statusbar_stats, TR_KEY_statusbar_stats_kebab }, - { TR_KEY_tcp_enabled, TR_KEY_tcp_enabled_kebab }, + { TR_KEY_tcp_enabled, TR_KEY_tcp_enabled_kebab_APICOMPAT }, { TR_KEY_time_checked, TR_KEY_time_checked_kebab }, { TR_KEY_torrent_added_notification_enabled, TR_KEY_torrent_added_notification_enabled_kebab }, { TR_KEY_torrent_added_verify_mode, TR_KEY_torrent_added_verify_mode_kebab }, @@ -392,12 +393,12 @@ auto constexpr SessionKeys = std::array{ { { TR_KEY_torrent_complete_sound_command, TR_KEY_torrent_complete_sound_command_kebab }, { TR_KEY_torrent_complete_sound_enabled, TR_KEY_torrent_complete_sound_enabled_kebab }, { TR_KEY_trash_can_enabled, TR_KEY_trash_can_enabled_kebab }, - { TR_KEY_trash_original_torrent_files, TR_KEY_trash_original_torrent_files_kebab }, + { TR_KEY_trash_original_torrent_files, TR_KEY_trash_original_torrent_files_kebab_APICOMPAT }, { TR_KEY_upload_slots_per_torrent, TR_KEY_upload_slots_per_torrent_kebab }, { TR_KEY_uploaded_bytes, TR_KEY_uploaded_bytes_kebab_APICOMPAT }, { TR_KEY_use_global_speed_limit, TR_KEY_use_global_speed_limit_kebab_APICOMPAT }, { TR_KEY_use_speed_limit, TR_KEY_use_speed_limit_kebab_APICOMPAT }, - { TR_KEY_utp_enabled, TR_KEY_utp_enabled_kebab }, + { TR_KEY_utp_enabled, TR_KEY_utp_enabled_kebab_APICOMPAT }, { TR_KEY_watch_dir, TR_KEY_watch_dir_kebab }, { TR_KEY_watch_dir_enabled, TR_KEY_watch_dir_enabled_kebab }, { TR_KEY_watch_dir_force_generic, TR_KEY_watch_dir_force_generic_kebab }, @@ -494,7 +495,7 @@ struct State if (auto const* const args = top.find_if(state.was_jsonrpc ? TR_KEY_result : TR_KEY_arguments)) { state.is_free_space_response = args->contains(TR_KEY_path) && - args->contains(state.was_jsonrpc ? TR_KEY_size_bytes : TR_KEY_size_bytes_kebab); + args->contains(state.was_jsonrpc ? TR_KEY_size_bytes : TR_KEY_size_bytes_kebab_APICOMPAT); } } @@ -509,7 +510,9 @@ struct State // download-dir in Tr4 session-get // downloadDir in Tr4 torrent-get // download_dir in Tr5 - if (state.is_rpc && (src == TR_KEY_download_dir_camel || src == TR_KEY_download_dir_kebab || src == TR_KEY_download_dir)) + if (state.is_rpc && + (src == TR_KEY_download_dir_camel_APICOMPAT || src == TR_KEY_download_dir_kebab_APICOMPAT || + src == TR_KEY_download_dir)) { if (state.style == Style::Tr5) { @@ -518,19 +521,20 @@ struct State if (state.is_torrent) { - return TR_KEY_download_dir_camel; + return TR_KEY_download_dir_camel_APICOMPAT; } - return TR_KEY_download_dir_kebab; + return TR_KEY_download_dir_kebab_APICOMPAT; } // Crazy case: // totalSize in Tr4 torrent-get // total_size in Tr4 free-space // total_size in Tr5 - if (state.is_rpc && state.is_free_space_response && (src == TR_KEY_total_size || src == TR_KEY_total_size_camel)) + if (state.is_rpc && state.is_free_space_response && (src == TR_KEY_total_size || src == TR_KEY_total_size_camel_APICOMPAT)) { - return state.style == Style::Tr5 || state.is_free_space_response ? TR_KEY_total_size : TR_KEY_total_size_camel; + return state.style == Style::Tr5 || state.is_free_space_response ? TR_KEY_total_size : + TR_KEY_total_size_camel_APICOMPAT; } // Crazy cases done. @@ -682,6 +686,10 @@ void convert_jsonrpc(tr_variant::Map& top, State const& state) if (is_jsonrpc) { top.try_emplace(TR_KEY_jsonrpc, tr_variant::unmanaged_string(JsonRpc::Version)); + if (auto const tag = top.value_if(TR_KEY_tag); state.was_legacy && !tag) + { + top.erase(TR_KEY_tag); + } top.replace_key(TR_KEY_tag, TR_KEY_id); } else @@ -719,7 +727,7 @@ void convert_jsonrpc(tr_variant::Map& top, State const& state) if (auto* data = error.find_if(TR_KEY_data)) { - if (auto const errmsg = data->value_if(TR_KEY_error_string_camel)) + if (auto const errmsg = data->value_if(TR_KEY_error_string_camel_APICOMPAT)) { top.try_emplace(TR_KEY_result, *errmsg); } diff --git a/libtransmission/quark.h b/libtransmission/quark.h index 1264b6875..b1c4201a0 100644 --- a/libtransmission/quark.h +++ b/libtransmission/quark.h @@ -33,26 +33,26 @@ using tr_quark = size_t; enum // NOLINT(performance-enum-size) { TR_KEY_NONE, /* represented as an empty string */ - TR_KEY_active_torrent_count_camel, /* rpc (deprecated) */ + TR_KEY_active_torrent_count_camel_APICOMPAT, TR_KEY_active_torrent_count, /* rpc */ TR_KEY_activity_date_kebab_APICOMPAT, - TR_KEY_activity_date_camel, /* rpc (deprecated) */ + TR_KEY_activity_date_camel_APICOMPAT, TR_KEY_activity_date, /* rpc, resume file */ TR_KEY_added, /* pex */ - TR_KEY_added_date_kebab_APICOMPAT, /* resume file (legacy) */ + TR_KEY_added_date_kebab_APICOMPAT, TR_KEY_added_f, /* pex */ TR_KEY_added6, /* pex */ TR_KEY_added6_f, /* pex */ - TR_KEY_added_date_camel, /* rpc (deprecated) */ + TR_KEY_added_date_camel_APICOMPAT, TR_KEY_added_date, /* rpc, resume file */ TR_KEY_address, /* rpc */ - TR_KEY_alt_speed_down_kebab, /* rpc, settings (deprecated) */ - TR_KEY_alt_speed_enabled_kebab, /* rpc, settings (deprecated) */ - TR_KEY_alt_speed_time_begin_kebab, /* rpc, settings (deprecated) */ - TR_KEY_alt_speed_time_day_kebab, /* rpc, settings (deprecated) */ - TR_KEY_alt_speed_time_enabled_kebab, /* rpc, settings (deprecated) */ - TR_KEY_alt_speed_time_end_kebab, /* rpc, settings (deprecated) */ - TR_KEY_alt_speed_up_kebab, /* rpc, settings (deprecated) */ + TR_KEY_alt_speed_down_kebab_APICOMPAT, + TR_KEY_alt_speed_enabled_kebab_APICOMPAT, + TR_KEY_alt_speed_time_begin_kebab_APICOMPAT, + TR_KEY_alt_speed_time_day_kebab_APICOMPAT, + TR_KEY_alt_speed_time_enabled_kebab_APICOMPAT, + TR_KEY_alt_speed_time_end_kebab_APICOMPAT, + TR_KEY_alt_speed_up_kebab_APICOMPAT, TR_KEY_alt_speed_down, /* rpc, settings */ TR_KEY_alt_speed_enabled, /* rpc, settings */ TR_KEY_alt_speed_time_begin, /* rpc, settings */ @@ -64,18 +64,18 @@ enum // NOLINT(performance-enum-size) TR_KEY_announce_ip_kebab, /* settings (legacy) */ TR_KEY_announce_ip_enabled_kebab, /* settings (legacy) */ TR_KEY_announce_list, /* metainfo */ - TR_KEY_announce_state_camel, /* rpc (deprecated) */ + TR_KEY_announce_state_camel_APICOMPAT, TR_KEY_announce_ip, /* settings */ TR_KEY_announce_ip_enabled, /* settings */ TR_KEY_announce_state, /* rpc */ - TR_KEY_anti_brute_force_enabled_kebab, /* rpc, settings (deprecated) */ - TR_KEY_anti_brute_force_threshold_kebab, /* rpc, settings (deprecated) */ + TR_KEY_anti_brute_force_enabled_kebab_APICOMPAT, + TR_KEY_anti_brute_force_threshold_kebab_APICOMPAT, TR_KEY_anti_brute_force_enabled, /* rpc, settings */ TR_KEY_anti_brute_force_threshold, /* rpc, settings */ TR_KEY_arguments, /* rpc */ TR_KEY_availability, // rpc TR_KEY_bandwidth_priority_kebab_APICOMPAT, - TR_KEY_bandwidth_priority_camel, + TR_KEY_bandwidth_priority_camel_APICOMPAT, TR_KEY_bandwidth_priority, TR_KEY_begin_piece, TR_KEY_bind_address_ipv4_kebab, @@ -84,11 +84,11 @@ enum // NOLINT(performance-enum-size) TR_KEY_bind_address_ipv6, TR_KEY_bitfield, TR_KEY_blocklist_date_kebab, - TR_KEY_blocklist_enabled_kebab, - TR_KEY_blocklist_size_kebab, + TR_KEY_blocklist_enabled_kebab_APICOMPAT, + TR_KEY_blocklist_size_kebab_APICOMPAT, TR_KEY_blocklist_update_kebab, TR_KEY_blocklist_updates_enabled_kebab, - TR_KEY_blocklist_url_kebab, + TR_KEY_blocklist_url_kebab_APICOMPAT, TR_KEY_blocklist_date, TR_KEY_blocklist_enabled, TR_KEY_blocklist_size, @@ -96,15 +96,15 @@ enum // NOLINT(performance-enum-size) TR_KEY_blocklist_updates_enabled, TR_KEY_blocklist_url, TR_KEY_blocks, - TR_KEY_bytes_completed_camel, + TR_KEY_bytes_completed_camel_APICOMPAT, TR_KEY_bytes_completed, TR_KEY_bytes_to_client, TR_KEY_bytes_to_peer, - TR_KEY_cache_size_mb_kebab, + TR_KEY_cache_size_mb_kebab_APICOMPAT, TR_KEY_cache_size_mb, - TR_KEY_client_is_choked_camel, - TR_KEY_client_is_interested_camel, - TR_KEY_client_name_camel, + TR_KEY_client_is_choked_camel_APICOMPAT, + TR_KEY_client_is_interested_camel_APICOMPAT, + TR_KEY_client_name_camel_APICOMPAT, TR_KEY_client_is_choked, TR_KEY_client_is_interested, TR_KEY_client_name, @@ -113,48 +113,48 @@ enum // NOLINT(performance-enum-size) TR_KEY_compact_view_kebab, TR_KEY_compact_view, TR_KEY_complete, - TR_KEY_config_dir_kebab, + TR_KEY_config_dir_kebab_APICOMPAT, TR_KEY_config_dir, TR_KEY_cookies, TR_KEY_corrupt, - TR_KEY_corrupt_ever_camel, + TR_KEY_corrupt_ever_camel_APICOMPAT, TR_KEY_corrupt_ever, TR_KEY_created_by, TR_KEY_creation_date, TR_KEY_creator, - TR_KEY_cumulative_stats_kebab, + TR_KEY_cumulative_stats_kebab_APICOMPAT, TR_KEY_cumulative_stats, - TR_KEY_current_stats_kebab, + TR_KEY_current_stats_kebab_APICOMPAT, TR_KEY_current_stats, TR_KEY_data, - TR_KEY_date_created_camel, + TR_KEY_date_created_camel_APICOMPAT, TR_KEY_date_created, - TR_KEY_default_trackers_kebab, + TR_KEY_default_trackers_kebab_APICOMPAT, TR_KEY_default_trackers, - TR_KEY_delete_local_data_kebab, + TR_KEY_delete_local_data_kebab_APICOMPAT, TR_KEY_delete_local_data, - TR_KEY_desired_available_camel, + TR_KEY_desired_available_camel_APICOMPAT, TR_KEY_desired_available, TR_KEY_destination, TR_KEY_details_window_height_kebab, TR_KEY_details_window_width_kebab, TR_KEY_details_window_height, TR_KEY_details_window_width, - TR_KEY_dht_enabled_kebab, + TR_KEY_dht_enabled_kebab_APICOMPAT, TR_KEY_dht_enabled, TR_KEY_dnd, TR_KEY_done_date_kebab_APICOMPAT, - TR_KEY_done_date_camel, + TR_KEY_done_date_camel_APICOMPAT, TR_KEY_done_date, - TR_KEY_download_dir_kebab, - TR_KEY_download_dir_free_space_kebab, - TR_KEY_download_queue_enabled_kebab, - TR_KEY_download_queue_size_kebab, - TR_KEY_download_count_camel, - TR_KEY_download_dir_camel, - TR_KEY_download_limit_camel, - TR_KEY_download_limited_camel, - TR_KEY_download_speed_camel, + TR_KEY_download_dir_kebab_APICOMPAT, + TR_KEY_download_dir_free_space_kebab_APICOMPAT, + TR_KEY_download_queue_enabled_kebab_APICOMPAT, + TR_KEY_download_queue_size_kebab_APICOMPAT, + TR_KEY_download_count_camel_APICOMPAT, + TR_KEY_download_dir_camel_APICOMPAT, + TR_KEY_download_limit_camel_APICOMPAT, + TR_KEY_download_limited_camel_APICOMPAT, + TR_KEY_download_speed_camel_APICOMPAT, TR_KEY_download_count, TR_KEY_download_dir, TR_KEY_download_dir_free_space, @@ -165,8 +165,8 @@ enum // NOLINT(performance-enum-size) TR_KEY_download_speed, TR_KEY_downloaded, TR_KEY_downloaded_bytes_kebab_APICOMPAT, - TR_KEY_downloaded_bytes_camel, - TR_KEY_downloaded_ever_camel, + TR_KEY_downloaded_bytes_camel_APICOMPAT, + TR_KEY_downloaded_ever_camel_APICOMPAT, TR_KEY_downloaded_bytes, TR_KEY_downloaded_ever, TR_KEY_downloader_count, @@ -175,28 +175,28 @@ enum // NOLINT(performance-enum-size) TR_KEY_dropped, TR_KEY_dropped6, TR_KEY_e, - TR_KEY_edit_date_camel, + TR_KEY_edit_date_camel_APICOMPAT, TR_KEY_edit_date, TR_KEY_encoding, TR_KEY_encryption, TR_KEY_end_piece, TR_KEY_error, - TR_KEY_error_string_camel, + TR_KEY_error_string_camel_APICOMPAT, TR_KEY_error_string, TR_KEY_eta, - TR_KEY_eta_idle_camel, + TR_KEY_eta_idle_camel_APICOMPAT, TR_KEY_eta_idle, TR_KEY_fields, - TR_KEY_file_count_kebab, - TR_KEY_file_stats_camel, + TR_KEY_file_count_kebab_APICOMPAT, + TR_KEY_file_stats_camel_APICOMPAT, TR_KEY_file_count, TR_KEY_file_stats, TR_KEY_filename, TR_KEY_files, TR_KEY_files_added_kebab_APICOMPAT, - TR_KEY_files_unwanted_kebab, - TR_KEY_files_wanted_kebab, - TR_KEY_files_added_camel, + TR_KEY_files_unwanted_kebab_APICOMPAT, + TR_KEY_files_wanted_kebab_APICOMPAT, + TR_KEY_files_added_camel_APICOMPAT, TR_KEY_files_added, TR_KEY_files_unwanted, TR_KEY_files_wanted, @@ -206,19 +206,19 @@ enum // NOLINT(performance-enum-size) TR_KEY_filter_mode, TR_KEY_filter_text, TR_KEY_filter_trackers, - TR_KEY_flag_str_camel, + TR_KEY_flag_str_camel_APICOMPAT, TR_KEY_flag_str, TR_KEY_flags, TR_KEY_format, TR_KEY_free_space_kebab, TR_KEY_free_space, - TR_KEY_from_cache_camel, - TR_KEY_from_dht_camel, - TR_KEY_from_incoming_camel, - TR_KEY_from_lpd_camel, - TR_KEY_from_ltep_camel, - TR_KEY_from_pex_camel, - TR_KEY_from_tracker_camel, + TR_KEY_from_cache_camel_APICOMPAT, + TR_KEY_from_dht_camel_APICOMPAT, + TR_KEY_from_incoming_camel_APICOMPAT, + TR_KEY_from_lpd_camel_APICOMPAT, + TR_KEY_from_ltep_camel_APICOMPAT, + TR_KEY_from_pex_camel_APICOMPAT, + TR_KEY_from_tracker_camel_APICOMPAT, TR_KEY_from_cache, TR_KEY_from_dht, TR_KEY_from_incoming, @@ -231,33 +231,33 @@ enum // NOLINT(performance-enum-size) TR_KEY_group_set_kebab, TR_KEY_group_get, TR_KEY_group_set, - TR_KEY_has_announced_camel, - TR_KEY_has_scraped_camel, + TR_KEY_has_announced_camel_APICOMPAT, + TR_KEY_has_scraped_camel_APICOMPAT, TR_KEY_has_announced, TR_KEY_has_scraped, - TR_KEY_hash_string_camel, + TR_KEY_hash_string_camel_APICOMPAT, TR_KEY_hash_string, - TR_KEY_have_unchecked_camel, - TR_KEY_have_valid_camel, + TR_KEY_have_unchecked_camel_APICOMPAT, + TR_KEY_have_valid_camel_APICOMPAT, TR_KEY_have_unchecked, TR_KEY_have_valid, - TR_KEY_honors_session_limits_camel, + TR_KEY_honors_session_limits_camel_APICOMPAT, TR_KEY_honors_session_limits, TR_KEY_host, TR_KEY_id, TR_KEY_id_timestamp, TR_KEY_idle_limit_kebab_APICOMPAT, TR_KEY_idle_mode_kebab_APICOMPAT, - TR_KEY_idle_seeding_limit_kebab, - TR_KEY_idle_seeding_limit_enabled_kebab, + TR_KEY_idle_seeding_limit_kebab_APICOMPAT, + TR_KEY_idle_seeding_limit_enabled_kebab_APICOMPAT, TR_KEY_idle_limit, TR_KEY_idle_mode, TR_KEY_idle_seeding_limit, TR_KEY_idle_seeding_limit_enabled, TR_KEY_ids, TR_KEY_incomplete, - TR_KEY_incomplete_dir_kebab, - TR_KEY_incomplete_dir_enabled_kebab, + TR_KEY_incomplete_dir_kebab_APICOMPAT, + TR_KEY_incomplete_dir_enabled_kebab_APICOMPAT, TR_KEY_incomplete_dir, TR_KEY_incomplete_dir_enabled, TR_KEY_info, @@ -266,15 +266,15 @@ enum // NOLINT(performance-enum-size) TR_KEY_ip_protocol, TR_KEY_ipv4, TR_KEY_ipv6, - TR_KEY_is_backup_camel, - TR_KEY_is_downloading_from_camel, - TR_KEY_is_encrypted_camel, - TR_KEY_is_finished_camel, - TR_KEY_is_incoming_camel, - TR_KEY_is_private_camel, - TR_KEY_is_stalled_camel, - TR_KEY_is_utp_camel, - TR_KEY_is_uploading_to_camel, + TR_KEY_is_backup_camel_APICOMPAT, + TR_KEY_is_downloading_from_camel_APICOMPAT, + TR_KEY_is_encrypted_camel_APICOMPAT, + TR_KEY_is_finished_camel_APICOMPAT, + TR_KEY_is_incoming_camel_APICOMPAT, + TR_KEY_is_private_camel_APICOMPAT, + TR_KEY_is_stalled_camel_APICOMPAT, + TR_KEY_is_utp_camel_APICOMPAT, + TR_KEY_is_uploading_to_camel_APICOMPAT, TR_KEY_is_backup, TR_KEY_is_downloading_from, TR_KEY_is_encrypted, @@ -286,17 +286,17 @@ enum // NOLINT(performance-enum-size) TR_KEY_is_utp, TR_KEY_jsonrpc, TR_KEY_labels, - TR_KEY_last_announce_peer_count_camel, - TR_KEY_last_announce_result_camel, - TR_KEY_last_announce_start_time_camel, - TR_KEY_last_announce_succeeded_camel, - TR_KEY_last_announce_time_camel, - TR_KEY_last_announce_timed_out_camel, - TR_KEY_last_scrape_result_camel, - TR_KEY_last_scrape_start_time_camel, - TR_KEY_last_scrape_succeeded_camel, - TR_KEY_last_scrape_time_camel, - TR_KEY_last_scrape_timed_out_camel, + TR_KEY_last_announce_peer_count_camel_APICOMPAT, + TR_KEY_last_announce_result_camel_APICOMPAT, + TR_KEY_last_announce_start_time_camel_APICOMPAT, + TR_KEY_last_announce_succeeded_camel_APICOMPAT, + TR_KEY_last_announce_time_camel_APICOMPAT, + TR_KEY_last_announce_timed_out_camel_APICOMPAT, + TR_KEY_last_scrape_result_camel_APICOMPAT, + TR_KEY_last_scrape_start_time_camel_APICOMPAT, + TR_KEY_last_scrape_succeeded_camel_APICOMPAT, + TR_KEY_last_scrape_time_camel_APICOMPAT, + TR_KEY_last_scrape_timed_out_camel_APICOMPAT, TR_KEY_last_announce_peer_count, TR_KEY_last_announce_result, TR_KEY_last_announce_start_time, @@ -308,16 +308,16 @@ enum // NOLINT(performance-enum-size) TR_KEY_last_scrape_succeeded, TR_KEY_last_scrape_time, TR_KEY_last_scrape_timed_out, - TR_KEY_leecher_count_camel, + TR_KEY_leecher_count_camel_APICOMPAT, TR_KEY_leecher_count, - TR_KEY_left_until_done_camel, + TR_KEY_left_until_done_camel_APICOMPAT, TR_KEY_left_until_done, TR_KEY_length, TR_KEY_location, - TR_KEY_lpd_enabled_kebab, + TR_KEY_lpd_enabled_kebab_APICOMPAT, TR_KEY_lpd_enabled, TR_KEY_m, - TR_KEY_magnet_link_camel, + TR_KEY_magnet_link_camel_APICOMPAT, TR_KEY_magnet_link, TR_KEY_main_window_height_kebab, TR_KEY_main_window_is_maximized_kebab, @@ -331,20 +331,20 @@ enum // NOLINT(performance-enum-size) TR_KEY_main_window_width, TR_KEY_main_window_x, TR_KEY_main_window_y, - TR_KEY_manual_announce_time_camel, + TR_KEY_manual_announce_time_camel_APICOMPAT, TR_KEY_manual_announce_time, TR_KEY_max_peers_kebab_APICOMPAT, - TR_KEY_max_connected_peers_camel, + TR_KEY_max_connected_peers_camel_APICOMPAT, TR_KEY_max_connected_peers, TR_KEY_max_peers, - TR_KEY_memory_bytes_kebab, - TR_KEY_memory_units_kebab, + TR_KEY_memory_bytes_kebab_APICOMPAT, + TR_KEY_memory_units_kebab_APICOMPAT, TR_KEY_memory_bytes, TR_KEY_memory_units, TR_KEY_message, TR_KEY_message_level_kebab, TR_KEY_message_level, - TR_KEY_metadata_percent_complete_camel, + TR_KEY_metadata_percent_complete_camel_APICOMPAT, TR_KEY_metadata_percent_complete, TR_KEY_metadata_size, TR_KEY_metainfo, @@ -353,8 +353,8 @@ enum // NOLINT(performance-enum-size) TR_KEY_msg_type, TR_KEY_mtimes, TR_KEY_name, - TR_KEY_next_announce_time_camel, - TR_KEY_next_scrape_time_camel, + TR_KEY_next_announce_time_camel_APICOMPAT, + TR_KEY_next_scrape_time_camel_APICOMPAT, TR_KEY_next_announce_time, TR_KEY_next_scrape_time, TR_KEY_nodes, @@ -365,19 +365,19 @@ enum // NOLINT(performance-enum-size) TR_KEY_params, TR_KEY_path, TR_KEY_paused, - TR_KEY_paused_torrent_count_camel, + TR_KEY_paused_torrent_count_camel_APICOMPAT, TR_KEY_paused_torrent_count, TR_KEY_peer_congestion_algorithm_kebab, - TR_KEY_peer_limit_kebab, - TR_KEY_peer_limit_global_kebab, - TR_KEY_peer_limit_per_torrent_kebab, - TR_KEY_peer_port_kebab, + TR_KEY_peer_limit_kebab_APICOMPAT, + TR_KEY_peer_limit_global_kebab_APICOMPAT, + TR_KEY_peer_limit_per_torrent_kebab_APICOMPAT, + TR_KEY_peer_port_kebab_APICOMPAT, TR_KEY_peer_port_random_high_kebab, TR_KEY_peer_port_random_low_kebab, - TR_KEY_peer_port_random_on_start_kebab, + TR_KEY_peer_port_random_on_start_kebab_APICOMPAT, TR_KEY_peer_socket_tos_kebab, - TR_KEY_peer_is_choked_camel, - TR_KEY_peer_is_interested_camel, + TR_KEY_peer_is_choked_camel_APICOMPAT, + TR_KEY_peer_is_interested_camel_APICOMPAT, TR_KEY_peer_congestion_algorithm, TR_KEY_peer_id, TR_KEY_peer_is_choked, @@ -394,44 +394,44 @@ enum // NOLINT(performance-enum-size) TR_KEY_peers2, TR_KEY_peers2_6_kebab_APICOMPAT, TR_KEY_peers2_6, - TR_KEY_peers_connected_camel, - TR_KEY_peers_from_camel, - TR_KEY_peers_getting_from_us_camel, - TR_KEY_peers_sending_to_us_camel, + TR_KEY_peers_connected_camel_APICOMPAT, + TR_KEY_peers_from_camel_APICOMPAT, + TR_KEY_peers_getting_from_us_camel_APICOMPAT, + TR_KEY_peers_sending_to_us_camel_APICOMPAT, TR_KEY_peers_connected, TR_KEY_peers_from, TR_KEY_peers_getting_from_us, TR_KEY_peers_sending_to_us, - TR_KEY_percent_complete_camel, - TR_KEY_percent_done_camel, + TR_KEY_percent_complete_camel_APICOMPAT, + TR_KEY_percent_done_camel_APICOMPAT, TR_KEY_percent_complete, TR_KEY_percent_done, - TR_KEY_pex_enabled_kebab, + TR_KEY_pex_enabled_kebab_APICOMPAT, TR_KEY_pex_enabled, TR_KEY_pidfile, TR_KEY_piece, TR_KEY_piece_length, - TR_KEY_piece_count_camel, - TR_KEY_piece_size_camel, + TR_KEY_piece_count_camel_APICOMPAT, + TR_KEY_piece_size_camel_APICOMPAT, TR_KEY_piece_count, TR_KEY_piece_size, TR_KEY_pieces, TR_KEY_port, - TR_KEY_port_forwarding_enabled_kebab, - TR_KEY_port_is_open_kebab, + TR_KEY_port_forwarding_enabled_kebab_APICOMPAT, + TR_KEY_port_is_open_kebab_APICOMPAT, TR_KEY_port_test_kebab, TR_KEY_port_forwarding_enabled, TR_KEY_port_is_open, TR_KEY_port_test, TR_KEY_preallocation, TR_KEY_preferred_transports, - TR_KEY_primary_mime_type_kebab, + TR_KEY_primary_mime_type_kebab_APICOMPAT, TR_KEY_primary_mime_type, TR_KEY_priorities, TR_KEY_priority, - TR_KEY_priority_high_kebab, - TR_KEY_priority_low_kebab, - TR_KEY_priority_normal_kebab, + TR_KEY_priority_high_kebab_APICOMPAT, + TR_KEY_priority_low_kebab_APICOMPAT, + TR_KEY_priority_normal_kebab_APICOMPAT, TR_KEY_priority_high, TR_KEY_priority_low, TR_KEY_priority_normal, @@ -444,9 +444,9 @@ enum // NOLINT(performance-enum-size) TR_KEY_queue_move_down_kebab, TR_KEY_queue_move_top_kebab, TR_KEY_queue_move_up_kebab, - TR_KEY_queue_stalled_enabled_kebab, - TR_KEY_queue_stalled_minutes_kebab, - TR_KEY_queue_position_camel, + TR_KEY_queue_stalled_enabled_kebab_APICOMPAT, + TR_KEY_queue_stalled_minutes_kebab_APICOMPAT, + TR_KEY_queue_position_camel_APICOMPAT, TR_KEY_queue_move_bottom, TR_KEY_queue_move_down, TR_KEY_queue_move_top, @@ -454,10 +454,10 @@ enum // NOLINT(performance-enum-size) TR_KEY_queue_position, TR_KEY_queue_stalled_enabled, TR_KEY_queue_stalled_minutes, - TR_KEY_rate_download_camel, - TR_KEY_rate_to_client_camel, - TR_KEY_rate_to_peer_camel, - TR_KEY_rate_upload_camel, + TR_KEY_rate_download_camel_APICOMPAT, + TR_KEY_rate_to_client_camel_APICOMPAT, + TR_KEY_rate_to_peer_camel_APICOMPAT, + TR_KEY_rate_upload_camel_APICOMPAT, TR_KEY_rate_download, TR_KEY_rate_to_client, TR_KEY_rate_to_peer, @@ -470,9 +470,9 @@ enum // NOLINT(performance-enum-size) TR_KEY_ratio_mode, TR_KEY_read_clipboard_kebab, TR_KEY_read_clipboard, - TR_KEY_recently_active_kebab, + TR_KEY_recently_active_kebab_APICOMPAT, TR_KEY_recently_active, - TR_KEY_recheck_progress_camel, + TR_KEY_recheck_progress_camel_APICOMPAT, TR_KEY_recheck_progress, TR_KEY_remote_session_enabled_kebab, TR_KEY_remote_session_host_kebab, @@ -490,7 +490,7 @@ enum // NOLINT(performance-enum-size) TR_KEY_remote_session_rpc_url_path, TR_KEY_remote_session_username, TR_KEY_removed, - TR_KEY_rename_partial_files_kebab, + TR_KEY_rename_partial_files_kebab_APICOMPAT, TR_KEY_rename_partial_files, TR_KEY_reqq, TR_KEY_result, @@ -504,9 +504,9 @@ enum // NOLINT(performance-enum-size) TR_KEY_rpc_socket_mode_kebab, TR_KEY_rpc_url_kebab, TR_KEY_rpc_username_kebab, - TR_KEY_rpc_version_kebab, - TR_KEY_rpc_version_minimum_kebab, - TR_KEY_rpc_version_semver_kebab, + TR_KEY_rpc_version_kebab_APICOMPAT, + TR_KEY_rpc_version_minimum_kebab_APICOMPAT, + TR_KEY_rpc_version_semver_kebab_APICOMPAT, TR_KEY_rpc_whitelist_kebab, TR_KEY_rpc_whitelist_enabled_kebab, TR_KEY_rpc_authentication_required, @@ -526,15 +526,15 @@ enum // NOLINT(performance-enum-size) TR_KEY_rpc_whitelist_enabled, TR_KEY_scrape, TR_KEY_scrape_paused_torrents_enabled_kebab, - TR_KEY_scrape_state_camel, + TR_KEY_scrape_state_camel_APICOMPAT, TR_KEY_scrape_paused_torrents_enabled, TR_KEY_scrape_state, - TR_KEY_script_torrent_added_enabled_kebab, - TR_KEY_script_torrent_added_filename_kebab, - TR_KEY_script_torrent_done_enabled_kebab, - TR_KEY_script_torrent_done_filename_kebab, - TR_KEY_script_torrent_done_seeding_enabled_kebab, - TR_KEY_script_torrent_done_seeding_filename_kebab, + TR_KEY_script_torrent_added_enabled_kebab_APICOMPAT, + TR_KEY_script_torrent_added_filename_kebab_APICOMPAT, + TR_KEY_script_torrent_done_enabled_kebab_APICOMPAT, + TR_KEY_script_torrent_done_filename_kebab_APICOMPAT, + TR_KEY_script_torrent_done_seeding_enabled_kebab_APICOMPAT, + TR_KEY_script_torrent_done_seeding_filename_kebab_APICOMPAT, TR_KEY_script_torrent_added_enabled, TR_KEY_script_torrent_added_filename, TR_KEY_script_torrent_done_enabled, @@ -542,19 +542,19 @@ enum // NOLINT(performance-enum-size) TR_KEY_script_torrent_done_seeding_enabled, TR_KEY_script_torrent_done_seeding_filename, TR_KEY_seconds_active_kebab_APICOMPAT, - TR_KEY_seconds_active_camel, - TR_KEY_seconds_downloading_camel, - TR_KEY_seconds_seeding_camel, + TR_KEY_seconds_active_camel_APICOMPAT, + TR_KEY_seconds_downloading_camel_APICOMPAT, + TR_KEY_seconds_seeding_camel_APICOMPAT, TR_KEY_seconds_active, TR_KEY_seconds_downloading, TR_KEY_seconds_seeding, - TR_KEY_seed_queue_enabled_kebab, - TR_KEY_seed_queue_size_kebab, - TR_KEY_seed_idle_limit_camel, - TR_KEY_seed_idle_mode_camel, - TR_KEY_seed_ratio_limit_camel, - TR_KEY_seed_ratio_limited_camel, - TR_KEY_seed_ratio_mode_camel, + TR_KEY_seed_queue_enabled_kebab_APICOMPAT, + TR_KEY_seed_queue_size_kebab_APICOMPAT, + TR_KEY_seed_idle_limit_camel_APICOMPAT, + TR_KEY_seed_idle_mode_camel_APICOMPAT, + TR_KEY_seed_ratio_limit_camel_APICOMPAT, + TR_KEY_seed_ratio_limited_camel_APICOMPAT, + TR_KEY_seed_ratio_mode_camel_APICOMPAT, TR_KEY_seed_idle_limit, TR_KEY_seed_idle_mode, TR_KEY_seed_queue_enabled, @@ -562,7 +562,7 @@ enum // NOLINT(performance-enum-size) TR_KEY_seed_ratio_limit, TR_KEY_seed_ratio_limited, TR_KEY_seed_ratio_mode, - TR_KEY_seeder_count_camel, + TR_KEY_seeder_count_camel_APICOMPAT, TR_KEY_seeder_count, TR_KEY_seeding_time_seconds_kebab_APICOMPAT, TR_KEY_seeding_time_seconds, @@ -571,10 +571,10 @@ enum // NOLINT(performance-enum-size) TR_KEY_session_close_kebab, TR_KEY_session_count_kebab_APICOMPAT, TR_KEY_session_get_kebab, - TR_KEY_session_id_kebab, + TR_KEY_session_id_kebab_APICOMPAT, TR_KEY_session_set_kebab, TR_KEY_session_stats_kebab, - TR_KEY_session_count_camel, + TR_KEY_session_count_camel_APICOMPAT, TR_KEY_session_close, TR_KEY_session_count, TR_KEY_session_get, @@ -614,9 +614,9 @@ enum // NOLINT(performance-enum-size) TR_KEY_show_tracker_scrapes, TR_KEY_show_verifying, TR_KEY_sitename, - TR_KEY_size_bytes_kebab, - TR_KEY_size_units_kebab, - TR_KEY_size_when_done_camel, + TR_KEY_size_bytes_kebab_APICOMPAT, + TR_KEY_size_units_kebab_APICOMPAT, + TR_KEY_size_when_done_camel_APICOMPAT, TR_KEY_size_bytes, TR_KEY_size_units, TR_KEY_size_when_done, @@ -650,12 +650,12 @@ enum // NOLINT(performance-enum-size) TR_KEY_source, TR_KEY_speed, TR_KEY_speed_Bps_kebab_APICOMPAT, - TR_KEY_speed_bytes_kebab, - TR_KEY_speed_limit_down_kebab, - TR_KEY_speed_limit_down_enabled_kebab, - TR_KEY_speed_limit_up_kebab, - TR_KEY_speed_limit_up_enabled_kebab, - TR_KEY_speed_units_kebab, + TR_KEY_speed_bytes_kebab_APICOMPAT, + TR_KEY_speed_limit_down_kebab_APICOMPAT, + TR_KEY_speed_limit_down_enabled_kebab_APICOMPAT, + TR_KEY_speed_limit_up_kebab_APICOMPAT, + TR_KEY_speed_limit_up_enabled_kebab_APICOMPAT, + TR_KEY_speed_units_kebab_APICOMPAT, TR_KEY_speed_Bps, TR_KEY_speed_bytes, TR_KEY_speed_limit_down, @@ -663,9 +663,9 @@ enum // NOLINT(performance-enum-size) TR_KEY_speed_limit_up, TR_KEY_speed_limit_up_enabled, TR_KEY_speed_units, - TR_KEY_start_added_torrents_kebab, + TR_KEY_start_added_torrents_kebab_APICOMPAT, TR_KEY_start_minimized_kebab, - TR_KEY_start_date_camel, + TR_KEY_start_date_camel_APICOMPAT, TR_KEY_start_added_torrents, TR_KEY_start_date, TR_KEY_start_minimized, @@ -674,19 +674,19 @@ enum // NOLINT(performance-enum-size) TR_KEY_statusbar_stats_kebab, TR_KEY_statusbar_stats, TR_KEY_tag, - TR_KEY_tcp_enabled_kebab, + TR_KEY_tcp_enabled_kebab_APICOMPAT, TR_KEY_tcp_enabled, TR_KEY_tier, TR_KEY_time_checked_kebab, TR_KEY_time_checked, TR_KEY_torrent_add_kebab, - TR_KEY_torrent_added_kebab, + TR_KEY_torrent_added_kebab_APICOMPAT, TR_KEY_torrent_added_notification_enabled_kebab, TR_KEY_torrent_added_verify_mode_kebab, TR_KEY_torrent_complete_notification_enabled_kebab, TR_KEY_torrent_complete_sound_command_kebab, TR_KEY_torrent_complete_sound_enabled_kebab, - TR_KEY_torrent_duplicate_kebab, + TR_KEY_torrent_duplicate_kebab_APICOMPAT, TR_KEY_torrent_get_kebab, TR_KEY_torrent_reannounce_kebab, TR_KEY_torrent_remove_kebab, @@ -697,8 +697,8 @@ enum // NOLINT(performance-enum-size) TR_KEY_torrent_start_now_kebab, TR_KEY_torrent_stop_kebab, TR_KEY_torrent_verify_kebab, - TR_KEY_torrent_count_camel, - TR_KEY_torrent_file_camel, + TR_KEY_torrent_count_camel_APICOMPAT, + TR_KEY_torrent_file_camel_APICOMPAT, TR_KEY_torrent_add, TR_KEY_torrent_added, TR_KEY_torrent_added_notification_enabled, @@ -721,13 +721,13 @@ enum // NOLINT(performance-enum-size) TR_KEY_torrent_stop, TR_KEY_torrent_verify, TR_KEY_torrents, - TR_KEY_total_size_camel, + TR_KEY_total_size_camel_APICOMPAT, TR_KEY_total_size, - TR_KEY_tracker_add_camel, - TR_KEY_tracker_list_camel, - TR_KEY_tracker_remove_camel, - TR_KEY_tracker_replace_camel, - TR_KEY_tracker_stats_camel, + TR_KEY_tracker_add_camel_APICOMPAT, + TR_KEY_tracker_list_camel_APICOMPAT, + TR_KEY_tracker_remove_camel_APICOMPAT, + TR_KEY_tracker_replace_camel_APICOMPAT, + TR_KEY_tracker_stats_camel_APICOMPAT, TR_KEY_tracker_add, TR_KEY_tracker_list, TR_KEY_tracker_remove, @@ -735,16 +735,16 @@ enum // NOLINT(performance-enum-size) TR_KEY_tracker_stats, TR_KEY_trackers, TR_KEY_trash_can_enabled_kebab, - TR_KEY_trash_original_torrent_files_kebab, + TR_KEY_trash_original_torrent_files_kebab_APICOMPAT, TR_KEY_trash_can_enabled, TR_KEY_trash_original_torrent_files, TR_KEY_umask, TR_KEY_units, TR_KEY_upload_slots_per_torrent_kebab, - TR_KEY_upload_limit_camel, - TR_KEY_upload_limited_camel, - TR_KEY_upload_ratio_camel, - TR_KEY_upload_speed_camel, + TR_KEY_upload_limit_camel_APICOMPAT, + TR_KEY_upload_limited_camel_APICOMPAT, + TR_KEY_upload_ratio_camel_APICOMPAT, + TR_KEY_upload_speed_camel_APICOMPAT, TR_KEY_upload_limit, TR_KEY_upload_limited, TR_KEY_upload_only, @@ -753,8 +753,8 @@ enum // NOLINT(performance-enum-size) TR_KEY_upload_speed, TR_KEY_uploaded, TR_KEY_uploaded_bytes_kebab_APICOMPAT, - TR_KEY_uploaded_bytes_camel, - TR_KEY_uploaded_ever_camel, + TR_KEY_uploaded_bytes_camel_APICOMPAT, + TR_KEY_uploaded_ever_camel_APICOMPAT, TR_KEY_uploaded_bytes, TR_KEY_uploaded_ever, TR_KEY_url_list, @@ -765,7 +765,7 @@ enum // NOLINT(performance-enum-size) TR_KEY_ut_holepunch, TR_KEY_ut_metadata, TR_KEY_ut_pex, - TR_KEY_utp_enabled_kebab, + TR_KEY_utp_enabled_kebab_APICOMPAT, TR_KEY_utp_enabled, TR_KEY_v, TR_KEY_version, @@ -777,7 +777,7 @@ enum // NOLINT(performance-enum-size) TR_KEY_watch_dir_enabled, TR_KEY_watch_dir_force_generic, TR_KEY_webseeds, - TR_KEY_webseeds_sending_to_us_camel, + TR_KEY_webseeds_sending_to_us_camel_APICOMPAT, TR_KEY_webseeds_sending_to_us, TR_KEY_yourip, TR_N_KEYS diff --git a/libtransmission/rpcimpl.cc b/libtransmission/rpcimpl.cc index df22c6c6f..a1d57e589 100644 --- a/libtransmission/rpcimpl.cc +++ b/libtransmission/rpcimpl.cc @@ -151,9 +151,9 @@ namespace } // https://www.jsonrpc.org/specification#response_object -[[nodiscard]] tr_variant::Map build_response(Error::Code code, tr_variant id, tr_variant::Map&& body) +[[nodiscard]] tr_variant::Map build_response(Error::Code code, tr_variant id, tr_variant::Map&& body, bool is_jsonrpc = true) { - if (!is_valid_id(id)) + if (is_jsonrpc && !is_valid_id(id)) { TR_ASSERT(false); id = nullptr; @@ -199,44 +199,36 @@ struct tr_rpc_idle_data tr_session* session = nullptr; tr_variant::Map args_out; tr_rpc_response_func callback; + + // TODO: api-compat + bool is_jsonrpc; }; -void tr_rpc_idle_done_legacy(struct tr_rpc_idle_data* data, JsonRpc::Error::Code code, std::string_view result) -{ - // build the response - auto response_map = tr_variant::Map{ 3U }; - response_map.try_emplace(TR_KEY_arguments, std::move(data->args_out)); - response_map.try_emplace(TR_KEY_result, std::empty(result) ? JsonRpc::Error::to_string(code) : result); - if (auto& tag = data->id; tag.has_value()) - { - response_map.try_emplace(TR_KEY_tag, std::move(tag)); - } - - // send the response back to the listener - data->callback(data->session, tr_variant{ std::move(response_map) }); -} - void tr_rpc_idle_done(struct tr_rpc_idle_data* data, JsonRpc::Error::Code code, std::string_view errmsg) { using namespace JsonRpc; - if (data->id.has_value()) + if (!data->is_jsonrpc || data->id.has_value()) { auto const is_success = code == Error::SUCCESS; - data->callback( - data->session, - build_response( - code, - std::move(data->id), - is_success ? std::move(data->args_out) : Error::build_data(errmsg, std::move(data->args_out)))); + auto response = tr_variant{ build_response( + code, + std::move(data->id), + is_success ? std::move(data->args_out) : Error::build_data(errmsg, std::move(data->args_out)), + data->is_jsonrpc) }; + if (!data->is_jsonrpc) + { + libtransmission::api_compat::convert(response, libtransmission::api_compat::Style::Tr4); + } + data->callback(data->session, std::move(response)); } else // notification { data->callback(data->session, {}); } -} -using DoneCb = std::function; + delete data; +} // --- @@ -257,8 +249,7 @@ using DoneCb = std::function()) { - if (*val == tr_quark_get_string_view(TR_KEY_recently_active) || - *val == tr_quark_get_string_view(TR_KEY_recently_active_kebab)) + if (*val == tr_quark_get_string_view(TR_KEY_recently_active)) { auto const cutoff = tr_time() - RecentlyActiveSeconds; auto const recent = torrents.get_matching([cutoff](auto* walk) { return walk->has_changed_since(cutoff); }); @@ -411,8 +402,7 @@ void notifyBatchQueueChange(tr_session* session, std::vector const& tr_variant::Map const& args_in, tr_variant::Map& /*args_out*/) { - auto const delete_flag = args_in.value_if({ TR_KEY_delete_local_data, TR_KEY_delete_local_data_kebab }) - .value_or(false); + auto const delete_flag = args_in.value_if(TR_KEY_delete_local_data).value_or(false); auto const type = delete_flag ? TR_RPC_TORRENT_TRASHING : TR_RPC_TORRENT_REMOVING; for (auto* tor : getTorrents(session, args_in)) @@ -508,7 +498,6 @@ namespace make_torrent_field_helpers auto const file = tr_torrentFile(&tor, idx); auto stats_map = tr_variant::Map{ 3U }; stats_map.try_emplace(TR_KEY_bytes_completed, file.have); - stats_map.try_emplace(TR_KEY_bytes_completed_camel, file.have); stats_map.try_emplace(TR_KEY_priority, file.priority); stats_map.try_emplace(TR_KEY_wanted, file.wanted); vec.emplace_back(std::move(stats_map)); @@ -540,7 +529,6 @@ namespace make_torrent_field_helpers auto file_map = tr_variant::Map{ 5U }; file_map.try_emplace(TR_KEY_begin_piece, file.beginPiece); file_map.try_emplace(TR_KEY_bytes_completed, file.have); - file_map.try_emplace(TR_KEY_bytes_completed_camel, file.have); file_map.try_emplace(TR_KEY_end_piece, file.endPiece); file_map.try_emplace(TR_KEY_length, file.length); file_map.try_emplace(TR_KEY_name, file.name); @@ -590,51 +578,30 @@ namespace make_torrent_field_helpers auto stats_map = tr_variant::Map{ 28U }; stats_map.try_emplace(TR_KEY_announce, tracker.announce); stats_map.try_emplace(TR_KEY_announce_state, tracker.announceState); - stats_map.try_emplace(TR_KEY_announce_state_camel, tracker.announceState); stats_map.try_emplace(TR_KEY_download_count, tracker.downloadCount); - stats_map.try_emplace(TR_KEY_download_count_camel, tracker.downloadCount); stats_map.try_emplace(TR_KEY_downloader_count, tracker.downloader_count); stats_map.try_emplace(TR_KEY_has_announced, tracker.hasAnnounced); - stats_map.try_emplace(TR_KEY_has_announced_camel, tracker.hasAnnounced); stats_map.try_emplace(TR_KEY_has_scraped, tracker.hasScraped); - stats_map.try_emplace(TR_KEY_has_scraped_camel, tracker.hasScraped); stats_map.try_emplace(TR_KEY_host, tracker.host_and_port); stats_map.try_emplace(TR_KEY_id, tracker.id); stats_map.try_emplace(TR_KEY_is_backup, tracker.isBackup); - stats_map.try_emplace(TR_KEY_is_backup_camel, tracker.isBackup); stats_map.try_emplace(TR_KEY_last_announce_peer_count, tracker.lastAnnouncePeerCount); - stats_map.try_emplace(TR_KEY_last_announce_peer_count_camel, tracker.lastAnnouncePeerCount); stats_map.try_emplace(TR_KEY_last_announce_result, tracker.lastAnnounceResult); - stats_map.try_emplace(TR_KEY_last_announce_result_camel, tracker.lastAnnounceResult); stats_map.try_emplace(TR_KEY_last_announce_start_time, tracker.lastAnnounceStartTime); - stats_map.try_emplace(TR_KEY_last_announce_start_time_camel, tracker.lastAnnounceStartTime); stats_map.try_emplace(TR_KEY_last_announce_succeeded, tracker.lastAnnounceSucceeded); - stats_map.try_emplace(TR_KEY_last_announce_succeeded_camel, tracker.lastAnnounceSucceeded); stats_map.try_emplace(TR_KEY_last_announce_time, tracker.lastAnnounceTime); - stats_map.try_emplace(TR_KEY_last_announce_time_camel, tracker.lastAnnounceTime); stats_map.try_emplace(TR_KEY_last_announce_timed_out, tracker.lastAnnounceTimedOut); - stats_map.try_emplace(TR_KEY_last_announce_timed_out_camel, tracker.lastAnnounceTimedOut); stats_map.try_emplace(TR_KEY_last_scrape_result, tracker.lastScrapeResult); - stats_map.try_emplace(TR_KEY_last_scrape_result_camel, tracker.lastScrapeResult); stats_map.try_emplace(TR_KEY_last_scrape_start_time, tracker.lastScrapeStartTime); - stats_map.try_emplace(TR_KEY_last_scrape_start_time_camel, tracker.lastScrapeStartTime); stats_map.try_emplace(TR_KEY_last_scrape_succeeded, tracker.lastScrapeSucceeded); - stats_map.try_emplace(TR_KEY_last_scrape_succeeded_camel, tracker.lastScrapeSucceeded); stats_map.try_emplace(TR_KEY_last_scrape_time, tracker.lastScrapeTime); - stats_map.try_emplace(TR_KEY_last_scrape_time_camel, tracker.lastScrapeTime); stats_map.try_emplace(TR_KEY_last_scrape_timed_out, tracker.lastScrapeTimedOut); - stats_map.try_emplace(TR_KEY_last_scrape_timed_out_camel, tracker.lastScrapeTimedOut); stats_map.try_emplace(TR_KEY_leecher_count, tracker.leecherCount); - stats_map.try_emplace(TR_KEY_leecher_count_camel, tracker.leecherCount); stats_map.try_emplace(TR_KEY_next_announce_time, tracker.nextAnnounceTime); - stats_map.try_emplace(TR_KEY_next_announce_time_camel, tracker.nextAnnounceTime); stats_map.try_emplace(TR_KEY_next_scrape_time, tracker.nextScrapeTime); - stats_map.try_emplace(TR_KEY_next_scrape_time_camel, tracker.nextScrapeTime); stats_map.try_emplace(TR_KEY_scrape, tracker.scrape); stats_map.try_emplace(TR_KEY_scrape_state, tracker.scrapeState); - stats_map.try_emplace(TR_KEY_scrape_state_camel, tracker.scrapeState); stats_map.try_emplace(TR_KEY_seeder_count, tracker.seederCount); - stats_map.try_emplace(TR_KEY_seeder_count_camel, tracker.seederCount); stats_map.try_emplace(TR_KEY_sitename, tracker.sitename); stats_map.try_emplace(TR_KEY_tier, tracker.tier); vec.emplace_back(std::move(stats_map)); @@ -651,37 +618,24 @@ namespace make_torrent_field_helpers for (size_t idx = 0U; idx != n_peers; ++idx) { auto const& peer = peers[idx]; - auto peer_map = tr_variant::Map{ 16U }; + auto peer_map = tr_variant::Map{ 19U }; peer_map.try_emplace(TR_KEY_address, peer.addr); peer_map.try_emplace(TR_KEY_client_is_choked, peer.clientIsChoked); - peer_map.try_emplace(TR_KEY_client_is_choked_camel, peer.clientIsChoked); peer_map.try_emplace(TR_KEY_client_is_interested, peer.clientIsInterested); - peer_map.try_emplace(TR_KEY_client_is_interested_camel, peer.clientIsInterested); peer_map.try_emplace(TR_KEY_client_name, peer.client); - peer_map.try_emplace(TR_KEY_client_name_camel, peer.client); peer_map.try_emplace(TR_KEY_peer_id, tr_base64_encode(std::string_view{ peer.peer_id.data(), peer.peer_id.size() })); peer_map.try_emplace(TR_KEY_flag_str, peer.flagStr); - peer_map.try_emplace(TR_KEY_flag_str_camel, peer.flagStr); peer_map.try_emplace(TR_KEY_is_downloading_from, peer.isDownloadingFrom); - peer_map.try_emplace(TR_KEY_is_downloading_from_camel, peer.isDownloadingFrom); peer_map.try_emplace(TR_KEY_is_encrypted, peer.isEncrypted); - peer_map.try_emplace(TR_KEY_is_encrypted_camel, peer.isEncrypted); peer_map.try_emplace(TR_KEY_is_incoming, peer.isIncoming); - peer_map.try_emplace(TR_KEY_is_incoming_camel, peer.isIncoming); peer_map.try_emplace(TR_KEY_is_utp, peer.isUTP); - peer_map.try_emplace(TR_KEY_is_utp_camel, peer.isUTP); peer_map.try_emplace(TR_KEY_is_uploading_to, peer.isUploadingTo); - peer_map.try_emplace(TR_KEY_is_uploading_to_camel, peer.isUploadingTo); peer_map.try_emplace(TR_KEY_peer_is_choked, peer.peerIsChoked); - peer_map.try_emplace(TR_KEY_peer_is_choked_camel, peer.peerIsChoked); peer_map.try_emplace(TR_KEY_peer_is_interested, peer.peerIsInterested); - peer_map.try_emplace(TR_KEY_peer_is_interested_camel, peer.peerIsInterested); peer_map.try_emplace(TR_KEY_port, peer.port); peer_map.try_emplace(TR_KEY_progress, peer.progress); peer_map.try_emplace(TR_KEY_rate_to_client, Speed{ peer.rateToClient_KBps, Speed::Units::KByps }.base_quantity()); - peer_map.try_emplace(TR_KEY_rate_to_client_camel, Speed{ peer.rateToClient_KBps, Speed::Units::KByps }.base_quantity()); peer_map.try_emplace(TR_KEY_rate_to_peer, Speed{ peer.rateToPeer_KBps, Speed::Units::KByps }.base_quantity()); - peer_map.try_emplace(TR_KEY_rate_to_peer_camel, Speed{ peer.rateToPeer_KBps, Speed::Units::KByps }.base_quantity()); peer_map.try_emplace(TR_KEY_bytes_to_peer, peer.bytes_to_peer); peer_map.try_emplace(TR_KEY_bytes_to_client, peer.bytes_to_client); peers_vec.emplace_back(std::move(peer_map)); @@ -695,19 +649,12 @@ namespace make_torrent_field_helpers auto const& from = st.peersFrom; auto peer_counts_map = tr_variant::Map{ 7U }; peer_counts_map.try_emplace(TR_KEY_from_cache, from[TR_PEER_FROM_RESUME]); - peer_counts_map.try_emplace(TR_KEY_from_cache_camel, from[TR_PEER_FROM_RESUME]); peer_counts_map.try_emplace(TR_KEY_from_dht, from[TR_PEER_FROM_DHT]); - peer_counts_map.try_emplace(TR_KEY_from_dht_camel, from[TR_PEER_FROM_DHT]); peer_counts_map.try_emplace(TR_KEY_from_incoming, from[TR_PEER_FROM_INCOMING]); - peer_counts_map.try_emplace(TR_KEY_from_incoming_camel, from[TR_PEER_FROM_INCOMING]); peer_counts_map.try_emplace(TR_KEY_from_lpd, from[TR_PEER_FROM_LPD]); - peer_counts_map.try_emplace(TR_KEY_from_lpd_camel, from[TR_PEER_FROM_LPD]); peer_counts_map.try_emplace(TR_KEY_from_ltep, from[TR_PEER_FROM_LTEP]); - peer_counts_map.try_emplace(TR_KEY_from_ltep_camel, from[TR_PEER_FROM_LTEP]); peer_counts_map.try_emplace(TR_KEY_from_pex, from[TR_PEER_FROM_PEX]); - peer_counts_map.try_emplace(TR_KEY_from_pex_camel, from[TR_PEER_FROM_PEX]); peer_counts_map.try_emplace(TR_KEY_from_tracker, from[TR_PEER_FROM_TRACKER]); - peer_counts_map.try_emplace(TR_KEY_from_tracker_camel, from[TR_PEER_FROM_TRACKER]); return tr_variant{ std::move(peer_counts_map) }; } @@ -740,145 +687,85 @@ namespace make_torrent_field_helpers switch (key) { case TR_KEY_activity_date: - case TR_KEY_activity_date_camel: case TR_KEY_added_date: - case TR_KEY_added_date_camel: case TR_KEY_availability: case TR_KEY_bandwidth_priority: - case TR_KEY_bandwidth_priority_camel: case TR_KEY_bytes_completed: - case TR_KEY_bytes_completed_camel: case TR_KEY_comment: case TR_KEY_corrupt_ever: - case TR_KEY_corrupt_ever_camel: case TR_KEY_creator: case TR_KEY_date_created: - case TR_KEY_date_created_camel: case TR_KEY_desired_available: - case TR_KEY_desired_available_camel: case TR_KEY_done_date: - case TR_KEY_done_date_camel: case TR_KEY_download_dir: - case TR_KEY_download_dir_camel: case TR_KEY_download_limit: - case TR_KEY_download_limit_camel: case TR_KEY_download_limited: - case TR_KEY_download_limited_camel: case TR_KEY_downloaded_ever: - case TR_KEY_downloaded_ever_camel: case TR_KEY_edit_date: - case TR_KEY_edit_date_camel: case TR_KEY_error: case TR_KEY_error_string: - case TR_KEY_error_string_camel: case TR_KEY_eta: case TR_KEY_eta_idle: - case TR_KEY_eta_idle_camel: - case TR_KEY_file_stats: - case TR_KEY_file_stats_camel: case TR_KEY_file_count: - case TR_KEY_file_count_kebab: + case TR_KEY_file_stats: case TR_KEY_files: case TR_KEY_group: case TR_KEY_hash_string: - case TR_KEY_hash_string_camel: case TR_KEY_have_unchecked: - case TR_KEY_have_unchecked_camel: case TR_KEY_have_valid: - case TR_KEY_have_valid_camel: case TR_KEY_honors_session_limits: - case TR_KEY_honors_session_limits_camel: case TR_KEY_id: case TR_KEY_is_finished: - case TR_KEY_is_finished_camel: case TR_KEY_is_private: - case TR_KEY_is_private_camel: case TR_KEY_is_stalled: - case TR_KEY_is_stalled_camel: case TR_KEY_labels: case TR_KEY_left_until_done: - case TR_KEY_left_until_done_camel: case TR_KEY_magnet_link: - case TR_KEY_magnet_link_camel: case TR_KEY_manual_announce_time: - case TR_KEY_manual_announce_time_camel: case TR_KEY_max_connected_peers: - case TR_KEY_max_connected_peers_camel: case TR_KEY_metadata_percent_complete: - case TR_KEY_metadata_percent_complete_camel: case TR_KEY_name: case TR_KEY_peer_limit: - case TR_KEY_peer_limit_kebab: case TR_KEY_peers: case TR_KEY_peers_connected: - case TR_KEY_peers_connected_camel: case TR_KEY_peers_from: - case TR_KEY_peers_from_camel: case TR_KEY_peers_getting_from_us: - case TR_KEY_peers_getting_from_us_camel: case TR_KEY_peers_sending_to_us: - case TR_KEY_peers_sending_to_us_camel: case TR_KEY_percent_complete: - case TR_KEY_percent_complete_camel: case TR_KEY_percent_done: - case TR_KEY_percent_done_camel: case TR_KEY_piece_count: - case TR_KEY_piece_count_camel: case TR_KEY_piece_size: - case TR_KEY_piece_size_camel: case TR_KEY_pieces: case TR_KEY_primary_mime_type: - case TR_KEY_primary_mime_type_kebab: case TR_KEY_priorities: case TR_KEY_queue_position: - case TR_KEY_queue_position_camel: case TR_KEY_rate_download: - case TR_KEY_rate_download_camel: case TR_KEY_rate_upload: - case TR_KEY_rate_upload_camel: case TR_KEY_recheck_progress: - case TR_KEY_recheck_progress_camel: case TR_KEY_seconds_downloading: - case TR_KEY_seconds_downloading_camel: case TR_KEY_seconds_seeding: - case TR_KEY_seconds_seeding_camel: case TR_KEY_seed_idle_limit: - case TR_KEY_seed_idle_limit_camel: case TR_KEY_seed_idle_mode: - case TR_KEY_seed_idle_mode_camel: case TR_KEY_seed_ratio_limit: - case TR_KEY_seed_ratio_limit_camel: case TR_KEY_seed_ratio_mode: - case TR_KEY_seed_ratio_mode_camel: case TR_KEY_sequential_download: case TR_KEY_sequential_download_from_piece: case TR_KEY_size_when_done: - case TR_KEY_size_when_done_camel: case TR_KEY_source: case TR_KEY_start_date: - case TR_KEY_start_date_camel: case TR_KEY_status: case TR_KEY_torrent_file: - case TR_KEY_torrent_file_camel: case TR_KEY_total_size: - case TR_KEY_total_size_camel: case TR_KEY_tracker_list: - case TR_KEY_tracker_list_camel: case TR_KEY_tracker_stats: - case TR_KEY_tracker_stats_camel: case TR_KEY_trackers: case TR_KEY_upload_limit: - case TR_KEY_upload_limit_camel: case TR_KEY_upload_limited: - case TR_KEY_upload_limited_camel: case TR_KEY_upload_ratio: - case TR_KEY_upload_ratio_camel: case TR_KEY_uploaded_ever: - case TR_KEY_uploaded_ever_camel: case TR_KEY_wanted: case TR_KEY_webseeds: case TR_KEY_webseeds_sending_to_us: - case TR_KEY_webseeds_sending_to_us_camel: return true; default: @@ -895,225 +782,164 @@ namespace make_torrent_field_helpers switch (key) { case TR_KEY_activity_date: - case TR_KEY_activity_date_camel: return st.activityDate; case TR_KEY_added_date: - case TR_KEY_added_date_camel: return st.addedDate; case TR_KEY_availability: return make_piece_availability_vec(tor); case TR_KEY_bandwidth_priority: - case TR_KEY_bandwidth_priority_camel: return tor.get_priority(); case TR_KEY_bytes_completed: return make_bytes_completed_vec(tor); - case TR_KEY_bytes_completed_camel: - return make_bytes_completed_vec(tor); case TR_KEY_comment: return tor.comment(); case TR_KEY_corrupt_ever: - case TR_KEY_corrupt_ever_camel: return st.corruptEver; case TR_KEY_creator: return tor.creator(); case TR_KEY_date_created: - case TR_KEY_date_created_camel: return tor.date_created(); case TR_KEY_desired_available: - case TR_KEY_desired_available_camel: return st.desiredAvailable; case TR_KEY_done_date: - case TR_KEY_done_date_camel: return st.doneDate; case TR_KEY_download_dir: - case TR_KEY_download_dir_camel: return tr_variant::unmanaged_string(tor.download_dir().sv()); case TR_KEY_download_limit: - case TR_KEY_download_limit_camel: return tr_torrentGetSpeedLimit_KBps(&tor, TR_DOWN); case TR_KEY_download_limited: - case TR_KEY_download_limited_camel: return tor.uses_speed_limit(TR_DOWN); case TR_KEY_downloaded_ever: - case TR_KEY_downloaded_ever_camel: return st.downloadedEver; case TR_KEY_edit_date: - case TR_KEY_edit_date_camel: return st.editDate; case TR_KEY_error: return st.error; case TR_KEY_error_string: - case TR_KEY_error_string_camel: return st.errorString; case TR_KEY_eta: return st.eta; case TR_KEY_eta_idle: - case TR_KEY_eta_idle_camel: return st.etaIdle; - case TR_KEY_file_stats: - case TR_KEY_file_stats_camel: - return make_file_stats_vec(tor); case TR_KEY_file_count: - case TR_KEY_file_count_kebab: return tor.file_count(); + case TR_KEY_file_stats: + return make_file_stats_vec(tor); case TR_KEY_files: return make_file_vec(tor); case TR_KEY_group: return tr_variant::unmanaged_string(tor.bandwidth_group().sv()); case TR_KEY_hash_string: - case TR_KEY_hash_string_camel: return tr_variant::unmanaged_string(tor.info_hash_string().sv()); case TR_KEY_have_unchecked: - case TR_KEY_have_unchecked_camel: return st.haveUnchecked; case TR_KEY_have_valid: - case TR_KEY_have_valid_camel: return st.haveValid; case TR_KEY_honors_session_limits: - case TR_KEY_honors_session_limits_camel: return tor.uses_session_limits(); case TR_KEY_id: return st.id; case TR_KEY_is_finished: - case TR_KEY_is_finished_camel: return st.finished; case TR_KEY_is_private: - case TR_KEY_is_private_camel: return tor.is_private(); case TR_KEY_is_stalled: - case TR_KEY_is_stalled_camel: return st.isStalled; case TR_KEY_labels: return make_labels_vec(tor); case TR_KEY_left_until_done: - case TR_KEY_left_until_done_camel: return st.leftUntilDone; case TR_KEY_magnet_link: - case TR_KEY_magnet_link_camel: return tor.magnet(); case TR_KEY_manual_announce_time: - case TR_KEY_manual_announce_time_camel: return tr_announcerNextManualAnnounce(&tor); case TR_KEY_max_connected_peers: - case TR_KEY_max_connected_peers_camel: return tor.peer_limit(); case TR_KEY_metadata_percent_complete: - case TR_KEY_metadata_percent_complete_camel: return st.metadataPercentComplete; case TR_KEY_name: return tor.name(); case TR_KEY_peer_limit: - case TR_KEY_peer_limit_kebab: return tor.peer_limit(); case TR_KEY_peers: return make_peer_vec(tor); case TR_KEY_peers_connected: - case TR_KEY_peers_connected_camel: return st.peersConnected; case TR_KEY_peers_from: - case TR_KEY_peers_from_camel: return make_peer_counts_map(st); case TR_KEY_peers_getting_from_us: - case TR_KEY_peers_getting_from_us_camel: return st.peersGettingFromUs; case TR_KEY_peers_sending_to_us: - case TR_KEY_peers_sending_to_us_camel: return st.peersSendingToUs; case TR_KEY_percent_complete: - case TR_KEY_percent_complete_camel: return st.percentComplete; case TR_KEY_percent_done: - case TR_KEY_percent_done_camel: return st.percentDone; case TR_KEY_piece_count: - case TR_KEY_piece_count_camel: return tor.piece_count(); case TR_KEY_piece_size: - case TR_KEY_piece_size_camel: return tor.piece_size(); case TR_KEY_pieces: return make_piece_bitfield(tor); case TR_KEY_primary_mime_type: - case TR_KEY_primary_mime_type_kebab: return tr_variant::unmanaged_string(tor.primary_mime_type()); case TR_KEY_priorities: return make_file_priorities_vec(tor); case TR_KEY_queue_position: - case TR_KEY_queue_position_camel: return st.queuePosition; case TR_KEY_rate_download: - case TR_KEY_rate_download_camel: return Speed{ st.pieceDownloadSpeed_KBps, Speed::Units::KByps }.base_quantity(); case TR_KEY_rate_upload: - case TR_KEY_rate_upload_camel: return Speed{ st.pieceUploadSpeed_KBps, Speed::Units::KByps }.base_quantity(); case TR_KEY_recheck_progress: - case TR_KEY_recheck_progress_camel: return st.recheckProgress; case TR_KEY_seconds_downloading: - case TR_KEY_seconds_downloading_camel: return st.secondsDownloading; case TR_KEY_seconds_seeding: - case TR_KEY_seconds_seeding_camel: return st.secondsSeeding; case TR_KEY_seed_idle_limit: - case TR_KEY_seed_idle_limit_camel: return tor.idle_limit_minutes(); case TR_KEY_seed_idle_mode: - case TR_KEY_seed_idle_mode_camel: return tor.idle_limit_mode(); case TR_KEY_seed_ratio_limit: - case TR_KEY_seed_ratio_limit_camel: return tor.seed_ratio(); case TR_KEY_seed_ratio_mode: - case TR_KEY_seed_ratio_mode_camel: return tor.seed_ratio_mode(); case TR_KEY_sequential_download: return tor.is_sequential_download(); case TR_KEY_sequential_download_from_piece: return tor.sequential_download_from_piece(); case TR_KEY_size_when_done: - case TR_KEY_size_when_done_camel: return st.sizeWhenDone; case TR_KEY_source: return tor.source(); case TR_KEY_start_date: - case TR_KEY_start_date_camel: return st.startDate; case TR_KEY_status: return st.activity; case TR_KEY_torrent_file: - case TR_KEY_torrent_file_camel: return tor.torrent_file(); case TR_KEY_total_size: - case TR_KEY_total_size_camel: return tor.total_size(); case TR_KEY_tracker_list: - case TR_KEY_tracker_list_camel: return tor.announce_list().to_string(); case TR_KEY_tracker_stats: - case TR_KEY_tracker_stats_camel: return make_tracker_stats_vec(tor); case TR_KEY_trackers: return make_tracker_vec(tor); case TR_KEY_upload_limit: - case TR_KEY_upload_limit_camel: return tr_torrentGetSpeedLimit_KBps(&tor, TR_UP); case TR_KEY_upload_limited: - case TR_KEY_upload_limited_camel: return tor.uses_speed_limit(TR_UP); case TR_KEY_upload_ratio: - case TR_KEY_upload_ratio_camel: return st.ratio; case TR_KEY_uploaded_ever: - case TR_KEY_uploaded_ever_camel: return st.uploadedEver; case TR_KEY_wanted: return make_file_wanted_vec(tor); case TR_KEY_webseeds: return make_webseed_vec(tor); case TR_KEY_webseeds_sending_to_us: - case TR_KEY_webseeds_sending_to_us_camel: return st.webseedsSendingToUs; default: return tr_variant{}; @@ -1166,9 +992,7 @@ namespace make_torrent_field_helpers auto const format = args_in.value_if(TR_KEY_format).value_or("object"sv) == "table"sv ? TrFormat::Table : TrFormat::Object; - if (auto val = args_in.value_if(TR_KEY_ids).value_or(""sv); - val == tr_quark_get_string_view(TR_KEY_recently_active) || - val == tr_quark_get_string_view(TR_KEY_recently_active_kebab)) + if (auto val = args_in.value_if(TR_KEY_ids); val == tr_quark_get_string_view(TR_KEY_recently_active)) { auto const cutoff = tr_time() - RecentlyActiveSeconds; auto const ids = session->torrents().removedSince(cutoff); @@ -1435,7 +1259,7 @@ namespace make_torrent_field_helpers for (auto* tor : getTorrents(session, args_in)) { - if (auto const val = args_in.value_if({ TR_KEY_bandwidth_priority, TR_KEY_bandwidth_priority_camel }); val) + if (auto const val = args_in.value_if(TR_KEY_bandwidth_priority); val) { if (auto const priority = static_cast(*val); tr_isPriority(priority)) { @@ -1453,42 +1277,40 @@ namespace make_torrent_field_helpers std::tie(err, errmsg) = set_labels(tor, *val); } - if (auto const* val = args_in.find_if({ TR_KEY_files_unwanted, TR_KEY_files_unwanted_kebab }); + if (auto const* val = args_in.find_if(TR_KEY_files_unwanted); val != nullptr && err == Error::SUCCESS) { std::tie(err, errmsg) = set_file_dls(tor, false, *val); } - if (auto const* val = args_in.find_if({ TR_KEY_files_wanted, TR_KEY_files_wanted_kebab }); - val != nullptr && err == Error::SUCCESS) + if (auto const* val = args_in.find_if(TR_KEY_files_wanted); val != nullptr && err == Error::SUCCESS) { std::tie(err, errmsg) = set_file_dls(tor, true, *val); } - if (auto const val = args_in.value_if({ TR_KEY_peer_limit, TR_KEY_peer_limit_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_peer_limit); val) { tr_torrentSetPeerLimit(tor, *val); } - if (auto const* val = args_in.find_if({ TR_KEY_priority_high, TR_KEY_priority_high_kebab }); + if (auto const* val = args_in.find_if(TR_KEY_priority_high); val != nullptr && err == Error::SUCCESS) { std::tie(err, errmsg) = set_file_priorities(tor, TR_PRI_HIGH, *val); } - if (auto const* val = args_in.find_if({ TR_KEY_priority_low, TR_KEY_priority_low_kebab }); - val != nullptr && err == Error::SUCCESS) + if (auto const* val = args_in.find_if(TR_KEY_priority_low); val != nullptr && err == Error::SUCCESS) { std::tie(err, errmsg) = set_file_priorities(tor, TR_PRI_LOW, *val); } - if (auto const* val = args_in.find_if({ TR_KEY_priority_normal, TR_KEY_priority_normal_kebab }); + if (auto const* val = args_in.find_if(TR_KEY_priority_normal); val != nullptr && err == Error::SUCCESS) { std::tie(err, errmsg) = set_file_priorities(tor, TR_PRI_NORMAL, *val); } - if (auto const val = args_in.value_if({ TR_KEY_download_limit, TR_KEY_download_limit_camel }); val) + if (auto const val = args_in.value_if(TR_KEY_download_limit); val) { tr_torrentSetSpeedLimit_KBps(tor, TR_DOWN, *val); } @@ -1503,70 +1325,67 @@ namespace make_torrent_field_helpers std::tie(err, errmsg) = set_sequential_download_from_piece(*tor, *val); } - if (auto const val = args_in.value_if({ TR_KEY_download_limited, TR_KEY_download_limited_camel }); val) + if (auto const val = args_in.value_if(TR_KEY_download_limited); val) { tor->use_speed_limit(TR_DOWN, *val); } - if (auto const val = args_in.value_if({ TR_KEY_honors_session_limits, TR_KEY_honors_session_limits_camel }); val) + if (auto const val = args_in.value_if(TR_KEY_honors_session_limits); val) { tr_torrentUseSessionLimits(tor, *val); } - if (auto const val = args_in.value_if({ TR_KEY_upload_limit, TR_KEY_upload_limit_camel }); val) + if (auto const val = args_in.value_if(TR_KEY_upload_limit); val) { tr_torrentSetSpeedLimit_KBps(tor, TR_UP, *val); } - if (auto const val = args_in.value_if({ TR_KEY_upload_limited, TR_KEY_upload_limited_camel }); val) + if (auto const val = args_in.value_if(TR_KEY_upload_limited); val) { tor->use_speed_limit(TR_UP, *val); } - if (auto const val = args_in.value_if({ TR_KEY_seed_idle_limit, TR_KEY_seed_idle_limit_camel }); val) + if (auto const val = args_in.value_if(TR_KEY_seed_idle_limit); val) { tor->set_idle_limit_minutes(static_cast(*val)); } - if (auto const val = args_in.value_if({ TR_KEY_seed_idle_mode, TR_KEY_seed_idle_mode_camel }); val) + if (auto const val = args_in.value_if(TR_KEY_seed_idle_mode); val) { tor->set_idle_limit_mode(static_cast(*val)); } - if (auto const val = args_in.value_if({ TR_KEY_seed_ratio_limit, TR_KEY_seed_ratio_limit_camel }); val) + if (auto const val = args_in.value_if(TR_KEY_seed_ratio_limit); val) { tor->set_seed_ratio(*val); } - if (auto const val = args_in.value_if({ TR_KEY_seed_ratio_mode, TR_KEY_seed_ratio_mode_camel }); val) + if (auto const val = args_in.value_if(TR_KEY_seed_ratio_mode); val) { tor->set_seed_ratio_mode(static_cast(*val)); } - if (auto const val = args_in.value_if({ TR_KEY_queue_position, TR_KEY_queue_position_camel }); val) + if (auto const val = args_in.value_if(TR_KEY_queue_position); val) { tr_torrentSetQueuePosition(tor, static_cast(*val)); } - if (auto const* val = args_in.find_if({ TR_KEY_tracker_add, TR_KEY_tracker_add_camel }); - val != nullptr) + if (auto const* val = args_in.find_if(TR_KEY_tracker_add); val != nullptr) { std::tie(err, errmsg) = add_tracker_urls(tor, *val); } - if (auto const* val = args_in.find_if({ TR_KEY_tracker_remove, TR_KEY_tracker_remove_camel }); - val != nullptr) + if (auto const* val = args_in.find_if(TR_KEY_tracker_remove); val != nullptr) { std::tie(err, errmsg) = remove_trackers(tor, *val); } - if (auto const* val = args_in.find_if({ TR_KEY_tracker_replace, TR_KEY_tracker_replace_camel }); - val != nullptr) + if (auto const* val = args_in.find_if(TR_KEY_tracker_replace); val != nullptr) { std::tie(err, errmsg) = replace_trackers(tor, *val); } - if (auto const val = args_in.value_if({ TR_KEY_tracker_list, TR_KEY_tracker_list_camel }); val) + if (auto const val = args_in.value_if(TR_KEY_tracker_list); val) { if (!tor->set_announce_list(*val)) { @@ -1611,13 +1430,7 @@ namespace make_torrent_field_helpers // --- -void torrentRenamePathDone( - tr_torrent* tor, - char const* oldpath, - char const* newname, - int error, - DoneCb const& done_cb, - void* user_data) +void torrentRenamePathDone(tr_torrent* tor, char const* oldpath, char const* newname, int error, void* user_data) { using namespace JsonRpc; @@ -1627,22 +1440,24 @@ void torrentRenamePathDone( data->args_out.try_emplace(TR_KEY_path, oldpath); data->args_out.try_emplace(TR_KEY_name, newname); - auto const is_success = error == 0; - done_cb(data, is_success ? Error::SUCCESS : Error::SYSTEM_ERROR, is_success ? ""sv : tr_strerror(error)); + if (error == 0) + { + tr_rpc_idle_done(data, Error::SUCCESS, {}); + } + else + { + tr_rpc_idle_done(data, Error::SYSTEM_ERROR, tr_strerror(error)); + } } -void torrentRenamePath( - tr_session* session, - tr_variant::Map const& args_in, - DoneCb&& done_cb, - struct tr_rpc_idle_data* idle_data) +void torrentRenamePath(tr_session* session, tr_variant::Map const& args_in, struct tr_rpc_idle_data* idle_data) { using namespace JsonRpc; auto const torrents = getTorrents(session, args_in); if (std::size(torrents) != 1U) { - done_cb(idle_data, Error::INVALID_PARAMS, "torrent_rename_path requires 1 torrent"sv); + tr_rpc_idle_done(idle_data, Error::INVALID_PARAMS, "torrent_rename_path requires 1 torrent"sv); return; } @@ -1651,14 +1466,14 @@ void torrentRenamePath( torrents[0]->rename_path( oldpath, newname, - [cb = std::move(done_cb)](tr_torrent* tor, char const* old_path, char const* new_name, int error, void* user_data) - { torrentRenamePathDone(tor, old_path, new_name, error, cb, user_data); }, + [](tr_torrent* tor, char const* old_path, char const* new_name, int error, void* user_data) + { torrentRenamePathDone(tor, old_path, new_name, error, user_data); }, idle_data); } // --- -void onPortTested(tr_web::FetchResponse const& web_response, DoneCb const& done_cb) +void onPortTested(tr_web::FetchResponse const& web_response) { using namespace JsonRpc; @@ -1673,7 +1488,7 @@ void onPortTested(tr_web::FetchResponse const& web_response, DoneCb const& done_ if (status != 200) { - done_cb( + tr_rpc_idle_done( data, Error::HTTP_ERROR, fmt::format( @@ -1685,11 +1500,10 @@ void onPortTested(tr_web::FetchResponse const& web_response, DoneCb const& done_ auto const port_is_open = tr_strv_starts_with(body, '1'); data->args_out.try_emplace(TR_KEY_port_is_open, port_is_open); - data->args_out.try_emplace(TR_KEY_port_is_open_kebab, port_is_open); - done_cb(data, Error::SUCCESS, {}); + tr_rpc_idle_done(data, Error::SUCCESS, {}); } -void portTest(tr_session* session, tr_variant::Map const& args_in, DoneCb&& done_cb, struct tr_rpc_idle_data* idle_data) +void portTest(tr_session* session, tr_variant::Map const& args_in, struct tr_rpc_idle_data* idle_data) { using namespace JsonRpc; @@ -1713,14 +1527,14 @@ void portTest(tr_session* session, tr_variant::Map const& args_in, DoneCb&& done } else { - done_cb(idle_data, Error::INVALID_PARAMS, "invalid ip protocol string"sv); + tr_rpc_idle_done(idle_data, Error::INVALID_PARAMS, "invalid ip protocol string"sv); return; } } auto options = tr_web::FetchOptions{ url, - [cb = std::move(done_cb)](tr_web::FetchResponse const& r) { onPortTested(r, cb); }, + [](tr_web::FetchResponse const& r) { onPortTested(r); }, idle_data, }; options.timeout_secs = TimeoutSecs; @@ -1733,7 +1547,7 @@ void portTest(tr_session* session, tr_variant::Map const& args_in, DoneCb&& done // --- -void onBlocklistFetched(tr_web::FetchResponse const& web_response, DoneCb const& done_cb) +void onBlocklistFetched(tr_web::FetchResponse const& web_response) { using namespace JsonRpc; @@ -1744,7 +1558,7 @@ void onBlocklistFetched(tr_web::FetchResponse const& web_response, DoneCb const& if (status != 200) { // we failed to download the blocklist... - done_cb( + tr_rpc_idle_done( data, Error::HTTP_ERROR, fmt::format( @@ -1790,7 +1604,7 @@ void onBlocklistFetched(tr_web::FetchResponse const& web_response, DoneCb const& auto const filename = tr_pathbuf{ session->configDir(), "/blocklist.tmp"sv }; if (auto error = tr_error{}; !tr_file_save(filename, content, &error)) { - done_cb( + tr_rpc_idle_done( data, Error::SYSTEM_ERROR, fmt::format( @@ -1804,28 +1618,23 @@ void onBlocklistFetched(tr_web::FetchResponse const& web_response, DoneCb const& // feed it to the session and give the client a response auto const blocklist_size = tr_blocklistSetContent(session, filename); data->args_out.try_emplace(TR_KEY_blocklist_size, blocklist_size); - data->args_out.try_emplace(TR_KEY_blocklist_size_kebab, blocklist_size); tr_sys_path_remove(filename); - done_cb(data, Error::SUCCESS, {}); + tr_rpc_idle_done(data, Error::SUCCESS, {}); } -void blocklistUpdate( - tr_session* session, - tr_variant::Map const& /*args_in*/, - DoneCb&& done_cb, - struct tr_rpc_idle_data* idle_data) +void blocklistUpdate(tr_session* session, tr_variant::Map const& /*args_in*/, struct tr_rpc_idle_data* idle_data) { session->fetch( { session->blocklistUrl(), - [cb = std::move(done_cb)](tr_web::FetchResponse const& r) { onBlocklistFetched(r, cb); }, + [](tr_web::FetchResponse const& r) { onBlocklistFetched(r); }, idle_data, }); } // --- -void add_torrent_impl(struct tr_rpc_idle_data* data, DoneCb const& done_cb, tr_ctor& ctor) +void add_torrent_impl(struct tr_rpc_idle_data* data, tr_ctor& ctor) { using namespace JsonRpc; @@ -1834,7 +1643,7 @@ void add_torrent_impl(struct tr_rpc_idle_data* data, DoneCb const& done_cb, tr_c if (tor == nullptr && duplicate_of == nullptr) { - done_cb(data, Error::CORRUPT_TORRENT, {}); + tr_rpc_idle_done(data, Error::CORRUPT_TORRENT, {}); return; } @@ -1842,17 +1651,13 @@ void add_torrent_impl(struct tr_rpc_idle_data* data, DoneCb const& done_cb, tr_c TR_KEY_id, TR_KEY_name, TR_KEY_hash_string, - TR_KEY_hash_string_camel, }; if (duplicate_of != nullptr) { data->args_out.try_emplace( TR_KEY_torrent_duplicate, make_torrent_info(duplicate_of, TrFormat::Object, std::data(Fields), std::size(Fields))); - data->args_out.try_emplace( - TR_KEY_torrent_duplicate_kebab, - make_torrent_info(duplicate_of, TrFormat::Object, std::data(Fields), std::size(Fields))); - done_cb(data, Error::SUCCESS, {}); + tr_rpc_idle_done(data, Error::SUCCESS, {}); return; } @@ -1860,10 +1665,7 @@ void add_torrent_impl(struct tr_rpc_idle_data* data, DoneCb const& done_cb, tr_c data->args_out.try_emplace( TR_KEY_torrent_added, make_torrent_info(tor, TrFormat::Object, std::data(Fields), std::size(Fields))); - data->args_out.try_emplace( - TR_KEY_torrent_added_kebab, - make_torrent_info(tor, TrFormat::Object, std::data(Fields), std::size(Fields))); - done_cb(data, Error::SUCCESS, {}); + tr_rpc_idle_done(data, Error::SUCCESS, {}); } struct add_torrent_idle_data @@ -1878,7 +1680,7 @@ struct add_torrent_idle_data tr_ctor ctor; }; -void onMetadataFetched(tr_web::FetchResponse const& web_response, DoneCb const& done_cb) +void onMetadataFetched(tr_web::FetchResponse const& web_response) { auto const& [status, body, primary_ip, did_connect, did_timeout, user_data] = web_response; auto* data = static_cast(user_data); @@ -1893,11 +1695,11 @@ void onMetadataFetched(tr_web::FetchResponse const& web_response, DoneCb const& if (status == 200 || status == 221) /* http or ftp success.. */ { data->ctor.set_metainfo(body); - add_torrent_impl(data->data, done_cb, data->ctor); + add_torrent_impl(data->data, data->ctor); } else { - done_cb( + tr_rpc_idle_done( data->data, JsonRpc::Error::HTTP_ERROR, fmt::format( @@ -1931,7 +1733,7 @@ bool isCurlURL(std::string_view url) return files; } -void torrentAdd(tr_session* session, tr_variant::Map const& args_in, DoneCb&& done_cb, tr_rpc_idle_data* idle_data) +void torrentAdd(tr_session* session, tr_variant::Map const& args_in, tr_rpc_idle_data* idle_data) { using namespace JsonRpc; @@ -1941,14 +1743,14 @@ void torrentAdd(tr_session* session, tr_variant::Map const& args_in, DoneCb&& do auto const metainfo_base64 = args_in.value_if(TR_KEY_metainfo).value_or(""sv); if (std::empty(filename) && std::empty(metainfo_base64)) { - done_cb(idle_data, Error::INVALID_PARAMS, "no filename or metainfo specified"sv); + tr_rpc_idle_done(idle_data, Error::INVALID_PARAMS, "no filename or metainfo specified"sv); return; } - auto const download_dir = args_in.value_if({ TR_KEY_download_dir, TR_KEY_download_dir_kebab }); + auto const download_dir = args_in.value_if(TR_KEY_download_dir); if (download_dir && tr_sys_path_is_relative(*download_dir)) { - done_cb(idle_data, Error::PATH_NOT_ABSOLUTE, "download directory path is not absolute"sv); + tr_rpc_idle_done(idle_data, Error::PATH_NOT_ABSOLUTE, "download directory path is not absolute"sv); return; } @@ -1968,46 +1770,41 @@ void torrentAdd(tr_session* session, tr_variant::Map const& args_in, DoneCb&& do ctor.set_paused(TR_FORCE, *val); } - if (auto const val = args_in.value_if({ TR_KEY_peer_limit, TR_KEY_peer_limit_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_peer_limit); val) { ctor.set_peer_limit(TR_FORCE, static_cast(*val)); } - if (auto const val = args_in.value_if({ TR_KEY_bandwidth_priority, TR_KEY_bandwidth_priority_camel }); val) + if (auto const val = args_in.value_if(TR_KEY_bandwidth_priority); val) { ctor.set_bandwidth_priority(static_cast(*val)); } - if (auto const val = args_in.find_if({ TR_KEY_files_unwanted, TR_KEY_files_unwanted_kebab }); - val != nullptr) + if (auto const val = args_in.find_if(TR_KEY_files_unwanted); val != nullptr) { auto const files = file_list_from_list(*val); ctor.set_files_wanted(std::data(files), std::size(files), false); } - if (auto const val = args_in.find_if({ TR_KEY_files_wanted, TR_KEY_files_wanted_kebab }); - val != nullptr) + if (auto const val = args_in.find_if(TR_KEY_files_wanted); val != nullptr) { auto const files = file_list_from_list(*val); ctor.set_files_wanted(std::data(files), std::size(files), true); } - if (auto const val = args_in.find_if({ TR_KEY_priority_low, TR_KEY_priority_low_kebab }); - val != nullptr) + if (auto const val = args_in.find_if(TR_KEY_priority_low); val != nullptr) { auto const files = file_list_from_list(*val); ctor.set_file_priorities(std::data(files), std::size(files), TR_PRI_LOW); } - if (auto const* val = args_in.find_if({ TR_KEY_priority_normal, TR_KEY_priority_normal_kebab }); - val != nullptr) + if (auto const* val = args_in.find_if(TR_KEY_priority_normal); val != nullptr) { auto const files = file_list_from_list(*val); ctor.set_file_priorities(std::data(files), std::size(files), TR_PRI_NORMAL); } - if (auto const* val = args_in.find_if({ TR_KEY_priority_high, TR_KEY_priority_high_kebab }); - val != nullptr) + if (auto const* val = args_in.find_if(TR_KEY_priority_high); val != nullptr) { auto const files = file_list_from_list(*val); ctor.set_file_priorities(std::data(files), std::size(files), TR_PRI_HIGH); @@ -2019,7 +1816,7 @@ void torrentAdd(tr_session* session, tr_variant::Map const& args_in, DoneCb&& do if (err != Error::SUCCESS) { - done_cb(idle_data, err, errmsg); + tr_rpc_idle_done(idle_data, err, errmsg); return; } @@ -2043,7 +1840,7 @@ void torrentAdd(tr_session* session, tr_variant::Map const& args_in, DoneCb&& do auto* const d = new add_torrent_idle_data{ idle_data, std::move(ctor) }; auto options = tr_web::FetchOptions{ filename, - [cb = std::move(done_cb)](tr_web::FetchResponse const& r) { onMetadataFetched(r, cb); }, + [](tr_web::FetchResponse const& r) { onMetadataFetched(r); }, d, }; options.cookies = cookies; @@ -2068,11 +1865,11 @@ void torrentAdd(tr_session* session, tr_variant::Map const& args_in, DoneCb&& do if (!ok) { - done_cb(idle_data, Error::UNRECOGNIZED_INFO, {}); + tr_rpc_idle_done(idle_data, Error::UNRECOGNIZED_INFO, {}); return; } - add_torrent_impl(idle_data, done_cb, ctor); + add_torrent_impl(idle_data, ctor); } // --- @@ -2111,18 +1908,13 @@ void add_strings_from_var(std::set& strings, tr_variant const& if (names.empty() || names.count(name.sv()) > 0U) { auto const limits = group->get_limits(); - auto group_map = tr_variant::Map{ 11U }; + auto group_map = tr_variant::Map{ 6U }; group_map.try_emplace(TR_KEY_honors_session_limits, group->are_parent_limits_honored(TR_UP)); - group_map.try_emplace(TR_KEY_honors_session_limits_camel, group->are_parent_limits_honored(TR_UP)); group_map.try_emplace(TR_KEY_name, name.sv()); group_map.try_emplace(TR_KEY_speed_limit_down, limits.down_limit.count(Speed::Units::KByps)); - group_map.try_emplace(TR_KEY_speed_limit_down_kebab, limits.down_limit.count(Speed::Units::KByps)); group_map.try_emplace(TR_KEY_speed_limit_down_enabled, limits.down_limited); - group_map.try_emplace(TR_KEY_speed_limit_down_enabled_kebab, limits.down_limited); group_map.try_emplace(TR_KEY_speed_limit_up, limits.up_limit.count(Speed::Units::KByps)); - group_map.try_emplace(TR_KEY_speed_limit_up_kebab, limits.up_limit.count(Speed::Units::KByps)); group_map.try_emplace(TR_KEY_speed_limit_up_enabled, limits.up_limited); - group_map.try_emplace(TR_KEY_speed_limit_up_enabled_kebab, limits.up_limited); groups_vec.emplace_back(std::move(group_map)); } } @@ -2147,30 +1939,29 @@ void add_strings_from_var(std::set& strings, tr_variant const& auto& group = session->getBandwidthGroup(name); auto limits = group.get_limits(); - if (auto const val = args_in.value_if({ TR_KEY_speed_limit_down_enabled, TR_KEY_speed_limit_down_enabled_kebab }); - val) + if (auto const val = args_in.value_if(TR_KEY_speed_limit_down_enabled); val) { limits.down_limited = *val; } - if (auto const val = args_in.value_if({ TR_KEY_speed_limit_up_enabled, TR_KEY_speed_limit_up_enabled_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_speed_limit_up_enabled); val) { limits.up_limited = *val; } - if (auto const val = args_in.value_if({ TR_KEY_speed_limit_down, TR_KEY_speed_limit_down_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_speed_limit_down); val) { limits.down_limit = Speed{ *val, Speed::Units::KByps }; } - if (auto const val = args_in.value_if({ TR_KEY_speed_limit_up, TR_KEY_speed_limit_up_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_speed_limit_up); val) { limits.up_limit = Speed{ *val, Speed::Units::KByps }; } group.set_limits(limits); - if (auto const val = args_in.value_if({ TR_KEY_honors_session_limits, TR_KEY_honors_session_limits_camel }); val) + if (auto const val = args_in.value_if(TR_KEY_honors_session_limits); val) { group.honor_parent_limits(TR_UP, *val); group.honor_parent_limits(TR_DOWN, *val); @@ -2188,13 +1979,13 @@ void add_strings_from_var(std::set& strings, tr_variant const& { using namespace JsonRpc; - auto const download_dir = args_in.value_if({ TR_KEY_download_dir, TR_KEY_download_dir_kebab }); + auto const download_dir = args_in.value_if(TR_KEY_download_dir); if (download_dir && tr_sys_path_is_relative(*download_dir)) { return { Error::PATH_NOT_ABSOLUTE, "download directory path is not absolute"s }; } - auto const incomplete_dir = args_in.value_if({ TR_KEY_incomplete_dir, TR_KEY_incomplete_dir_kebab }); + auto const incomplete_dir = args_in.value_if(TR_KEY_incomplete_dir); if (incomplete_dir && tr_sys_path_is_relative(*incomplete_dir)) { return { Error::PATH_NOT_ABSOLUTE, "incomplete torrents directory path is not absolute"s }; @@ -2208,52 +1999,52 @@ void add_strings_from_var(std::set& strings, tr_variant const& } } - if (auto const val = args_in.value_if({ TR_KEY_cache_size_mb, TR_KEY_cache_size_mb_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_cache_size_mb); val) { tr_sessionSetCacheLimit_MB(session, *val); } - if (auto const val = args_in.value_if({ TR_KEY_alt_speed_up, TR_KEY_alt_speed_up_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_alt_speed_up); val) { tr_sessionSetAltSpeed_KBps(session, TR_UP, *val); } - if (auto const val = args_in.value_if({ TR_KEY_alt_speed_down, TR_KEY_alt_speed_down_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_alt_speed_down); val) { tr_sessionSetAltSpeed_KBps(session, TR_DOWN, *val); } - if (auto const val = args_in.value_if({ TR_KEY_alt_speed_enabled, TR_KEY_alt_speed_enabled_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_alt_speed_enabled); val) { tr_sessionUseAltSpeed(session, *val); } - if (auto const val = args_in.value_if({ TR_KEY_alt_speed_time_begin, TR_KEY_alt_speed_time_begin_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_alt_speed_time_begin); val) { tr_sessionSetAltSpeedBegin(session, static_cast(*val)); } - if (auto const val = args_in.value_if({ TR_KEY_alt_speed_time_end, TR_KEY_alt_speed_time_end_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_alt_speed_time_end); val) { tr_sessionSetAltSpeedEnd(session, static_cast(*val)); } - if (auto const val = args_in.value_if({ TR_KEY_alt_speed_time_day, TR_KEY_alt_speed_time_day_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_alt_speed_time_day); val) { tr_sessionSetAltSpeedDay(session, static_cast(*val)); } - if (auto const val = args_in.value_if({ TR_KEY_alt_speed_time_enabled, TR_KEY_alt_speed_time_enabled_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_alt_speed_time_enabled); val) { tr_sessionUseAltSpeedTime(session, *val); } - if (auto const val = args_in.value_if({ TR_KEY_blocklist_enabled, TR_KEY_blocklist_enabled_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_blocklist_enabled); val) { session->set_blocklist_enabled(*val); } - if (auto const val = args_in.value_if({ TR_KEY_blocklist_url, TR_KEY_blocklist_url_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_blocklist_url); val) { session->setBlocklistUrl(*val); } @@ -2263,27 +2054,27 @@ void add_strings_from_var(std::set& strings, tr_variant const& session->setDownloadDir(*download_dir); } - if (auto const val = args_in.value_if({ TR_KEY_queue_stalled_minutes, TR_KEY_queue_stalled_minutes_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_queue_stalled_minutes); val) { tr_sessionSetQueueStalledMinutes(session, static_cast(*val)); } - if (auto const val = args_in.value_if({ TR_KEY_queue_stalled_enabled, TR_KEY_queue_stalled_enabled_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_queue_stalled_enabled); val) { tr_sessionSetQueueStalledEnabled(session, *val); } - if (auto const val = args_in.value_if({ TR_KEY_default_trackers, TR_KEY_default_trackers_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_default_trackers); val) { session->setDefaultTrackers(*val); } - if (auto const val = args_in.value_if({ TR_KEY_download_queue_size, TR_KEY_download_queue_size_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_download_queue_size); val) { tr_sessionSetQueueSize(session, TR_DOWN, *val); } - if (auto const val = args_in.value_if({ TR_KEY_download_queue_enabled, TR_KEY_download_queue_enabled_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_download_queue_enabled); val) { tr_sessionSetQueueEnabled(session, TR_DOWN, *val); } @@ -2293,17 +2084,17 @@ void add_strings_from_var(std::set& strings, tr_variant const& session->setIncompleteDir(*incomplete_dir); } - if (auto const val = args_in.value_if({ TR_KEY_incomplete_dir_enabled, TR_KEY_incomplete_dir_enabled_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_incomplete_dir_enabled); val) { session->useIncompleteDir(*val); } - if (auto const val = args_in.value_if({ TR_KEY_peer_limit_global, TR_KEY_peer_limit_global_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_peer_limit_global); val) { tr_sessionSetPeerLimit(session, *val); } - if (auto const val = args_in.value_if({ TR_KEY_peer_limit_per_torrent, TR_KEY_peer_limit_per_torrent_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_peer_limit_per_torrent); val) { tr_sessionSetPeerLimitPerTorrent(session, *val); } @@ -2313,120 +2104,115 @@ void add_strings_from_var(std::set& strings, tr_variant const& session->set_reqq(*val); } - if (auto const val = args_in.value_if({ TR_KEY_pex_enabled, TR_KEY_pex_enabled_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_pex_enabled); val) { tr_sessionSetPexEnabled(session, *val); } - if (auto const val = args_in.value_if({ TR_KEY_dht_enabled, TR_KEY_dht_enabled_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_dht_enabled); val) { tr_sessionSetDHTEnabled(session, *val); } - if (auto const val = args_in.value_if({ TR_KEY_utp_enabled, TR_KEY_utp_enabled_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_utp_enabled); val) { tr_sessionSetUTPEnabled(session, *val); } - if (auto const val = args_in.value_if({ TR_KEY_lpd_enabled, TR_KEY_lpd_enabled_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_lpd_enabled); val) { tr_sessionSetLPDEnabled(session, *val); } - if (auto const val = args_in.value_if({ TR_KEY_peer_port_random_on_start, TR_KEY_peer_port_random_on_start_kebab }); - val) + if (auto const val = args_in.value_if(TR_KEY_peer_port_random_on_start); val) { tr_sessionSetPeerPortRandomOnStart(session, *val); } - if (auto const val = args_in.value_if({ TR_KEY_peer_port, TR_KEY_peer_port_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_peer_port); val) { tr_sessionSetPeerPort(session, *val); } - if (auto const val = args_in.value_if({ TR_KEY_port_forwarding_enabled, TR_KEY_port_forwarding_enabled_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_port_forwarding_enabled); val) { tr_sessionSetPortForwardingEnabled(session, *val); } - if (auto const val = args_in.value_if({ TR_KEY_rename_partial_files, TR_KEY_rename_partial_files_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_rename_partial_files); val) { tr_sessionSetIncompleteFileNamingEnabled(session, *val); } - if (auto const val = args_in.value_if({ TR_KEY_seed_ratio_limit, TR_KEY_seed_ratio_limit_camel }); val) + if (auto const val = args_in.value_if(TR_KEY_seed_ratio_limit); val) { tr_sessionSetRatioLimit(session, *val); } - if (auto const val = args_in.value_if({ TR_KEY_seed_ratio_limited, TR_KEY_seed_ratio_limited_camel }); val) + if (auto const val = args_in.value_if(TR_KEY_seed_ratio_limited); val) { tr_sessionSetRatioLimited(session, *val); } - if (auto const val = args_in.value_if({ TR_KEY_idle_seeding_limit, TR_KEY_idle_seeding_limit_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_idle_seeding_limit); val) { tr_sessionSetIdleLimit(session, *val); } - if (auto const val = args_in.value_if({ TR_KEY_idle_seeding_limit_enabled, TR_KEY_idle_seeding_limit_enabled_kebab }); - val) + if (auto const val = args_in.value_if(TR_KEY_idle_seeding_limit_enabled); val) { tr_sessionSetIdleLimited(session, *val); } - if (auto const val = args_in.value_if({ TR_KEY_start_added_torrents, TR_KEY_start_added_torrents_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_start_added_torrents); val) { tr_sessionSetPaused(session, !*val); } - if (auto const val = args_in.value_if({ TR_KEY_seed_queue_enabled, TR_KEY_seed_queue_enabled_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_seed_queue_enabled); val) { tr_sessionSetQueueEnabled(session, TR_UP, *val); } - if (auto const val = args_in.value_if({ TR_KEY_seed_queue_size, TR_KEY_seed_queue_size_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_seed_queue_size); val) { tr_sessionSetQueueSize(session, TR_UP, *val); } for (auto const& [enabled_key, script_key, script] : tr_session::Scripts) { - if (auto const val = args_in.value_if({ tr_quark_convert(enabled_key), enabled_key }); val) + if (auto const val = args_in.value_if(enabled_key); val) { session->useScript(script, *val); } - if (auto const val = args_in.value_if({ tr_quark_convert(script_key), script_key }); val) + if (auto const val = args_in.value_if(script_key); val) { session->setScript(script, *val); } } - if (auto const val = args_in.value_if( - { TR_KEY_trash_original_torrent_files, TR_KEY_trash_original_torrent_files_kebab }); - val) + if (auto const val = args_in.value_if(TR_KEY_trash_original_torrent_files); val) { tr_sessionSetDeleteSource(session, *val); } - if (auto const val = args_in.value_if({ TR_KEY_speed_limit_down, TR_KEY_speed_limit_down_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_speed_limit_down); val) { session->set_speed_limit(TR_DOWN, Speed{ *val, Speed::Units::KByps }); } - if (auto const val = args_in.value_if({ TR_KEY_speed_limit_down_enabled, TR_KEY_speed_limit_down_enabled_kebab }); - val) + if (auto const val = args_in.value_if(TR_KEY_speed_limit_down_enabled); val) { tr_sessionLimitSpeed(session, TR_DOWN, *val); } - if (auto const val = args_in.value_if({ TR_KEY_speed_limit_up, TR_KEY_speed_limit_up_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_speed_limit_up); val) { session->set_speed_limit(TR_UP, Speed{ *val, Speed::Units::KByps }); } - if (auto const val = args_in.value_if({ TR_KEY_speed_limit_up_enabled, TR_KEY_speed_limit_up_enabled_kebab }); val) + if (auto const val = args_in.value_if(TR_KEY_speed_limit_up_enabled); val) { tr_sessionLimitSpeed(session, TR_UP, *val); } @@ -2447,15 +2233,12 @@ void add_strings_from_var(std::set& strings, tr_variant const& } } - if (auto const val = args_in.value_if( - { TR_KEY_anti_brute_force_threshold, TR_KEY_anti_brute_force_threshold_kebab }); - val) + if (auto const val = args_in.value_if(TR_KEY_anti_brute_force_threshold); val) { tr_sessionSetAntiBruteForceThreshold(session, static_cast(*val)); } - if (auto const val = args_in.value_if({ TR_KEY_anti_brute_force_enabled, TR_KEY_anti_brute_force_enabled_kebab }); - val) + if (auto const val = args_in.value_if(TR_KEY_anti_brute_force_enabled); val) { tr_sessionSetAntiBruteForceEnabled(session, *val); } @@ -2479,15 +2262,10 @@ void add_strings_from_var(std::set& strings, tr_variant const& { auto stats_map = tr_variant::Map{ 5U }; stats_map.try_emplace(TR_KEY_downloaded_bytes, stats.downloadedBytes); - stats_map.try_emplace(TR_KEY_downloaded_bytes_camel, stats.downloadedBytes); stats_map.try_emplace(TR_KEY_files_added, stats.filesAdded); - stats_map.try_emplace(TR_KEY_files_added_camel, stats.filesAdded); stats_map.try_emplace(TR_KEY_seconds_active, stats.secondsActive); - stats_map.try_emplace(TR_KEY_seconds_active_camel, stats.secondsActive); stats_map.try_emplace(TR_KEY_session_count, stats.sessionCount); - stats_map.try_emplace(TR_KEY_session_count_camel, stats.sessionCount); stats_map.try_emplace(TR_KEY_uploaded_bytes, stats.uploadedBytes); - stats_map.try_emplace(TR_KEY_uploaded_bytes_camel, stats.uploadedBytes); return stats_map; }; @@ -2500,19 +2278,12 @@ void add_strings_from_var(std::set& strings, tr_variant const& args_out.reserve(std::size(args_out) + 7U); args_out.try_emplace(TR_KEY_active_torrent_count, n_running); - args_out.try_emplace(TR_KEY_active_torrent_count_camel, n_running); args_out.try_emplace(TR_KEY_cumulative_stats, make_stats_map(session->stats().cumulative())); - args_out.try_emplace(TR_KEY_cumulative_stats_kebab, make_stats_map(session->stats().cumulative())); args_out.try_emplace(TR_KEY_current_stats, make_stats_map(session->stats().current())); - args_out.try_emplace(TR_KEY_current_stats_kebab, make_stats_map(session->stats().current())); args_out.try_emplace(TR_KEY_download_speed, session->piece_speed(TR_DOWN).base_quantity()); - args_out.try_emplace(TR_KEY_download_speed_camel, session->piece_speed(TR_DOWN).base_quantity()); args_out.try_emplace(TR_KEY_paused_torrent_count, total - n_running); - args_out.try_emplace(TR_KEY_paused_torrent_count_camel, total - n_running); args_out.try_emplace(TR_KEY_torrent_count, total); - args_out.try_emplace(TR_KEY_torrent_count_camel, total); args_out.try_emplace(TR_KEY_upload_speed, session->piece_speed(TR_UP).base_quantity()); - args_out.try_emplace(TR_KEY_upload_speed_camel, session->piece_speed(TR_UP).base_quantity()); return { JsonRpc::Error::SUCCESS, {} }; } @@ -2553,17 +2324,11 @@ void add_strings_from_var(std::set& strings, tr_variant const& auto units_map = tr_variant::Map{ 6U }; units_map.try_emplace(TR_KEY_memory_bytes, Memory::units().base()); - units_map.try_emplace(TR_KEY_memory_bytes_kebab, Memory::units().base()); units_map.try_emplace(TR_KEY_memory_units, make_units_vec(Memory::units())); - units_map.try_emplace(TR_KEY_memory_units_kebab, make_units_vec(Memory::units())); units_map.try_emplace(TR_KEY_size_bytes, Storage::units().base()); - units_map.try_emplace(TR_KEY_size_bytes_kebab, Storage::units().base()); units_map.try_emplace(TR_KEY_size_units, make_units_vec(Storage::units())); - units_map.try_emplace(TR_KEY_size_units_kebab, make_units_vec(Storage::units())); units_map.try_emplace(TR_KEY_speed_bytes, Speed::units().base()); - units_map.try_emplace(TR_KEY_speed_bytes_kebab, Speed::units().base()); units_map.try_emplace(TR_KEY_speed_units, make_units_vec(Speed::units())); - units_map.try_emplace(TR_KEY_speed_units_kebab, make_units_vec(Speed::units())); return tr_variant{ std::move(units_map) }; } @@ -2572,182 +2337,126 @@ void add_strings_from_var(std::set& strings, tr_variant const& switch (key) { case TR_KEY_alt_speed_down: - case TR_KEY_alt_speed_down_kebab: return tr_sessionGetAltSpeed_KBps(&session, TR_DOWN); case TR_KEY_alt_speed_enabled: - case TR_KEY_alt_speed_enabled_kebab: return tr_sessionUsesAltSpeed(&session); case TR_KEY_alt_speed_time_begin: - case TR_KEY_alt_speed_time_begin_kebab: return tr_sessionGetAltSpeedBegin(&session); case TR_KEY_alt_speed_time_day: - case TR_KEY_alt_speed_time_day_kebab: return tr_sessionGetAltSpeedDay(&session); case TR_KEY_alt_speed_time_enabled: - case TR_KEY_alt_speed_time_enabled_kebab: return tr_sessionUsesAltSpeedTime(&session); case TR_KEY_alt_speed_time_end: - case TR_KEY_alt_speed_time_end_kebab: return tr_sessionGetAltSpeedEnd(&session); case TR_KEY_alt_speed_up: - case TR_KEY_alt_speed_up_kebab: return tr_sessionGetAltSpeed_KBps(&session, TR_UP); case TR_KEY_anti_brute_force_enabled: - case TR_KEY_anti_brute_force_enabled_kebab: return tr_sessionGetAntiBruteForceEnabled(&session); case TR_KEY_anti_brute_force_threshold: - case TR_KEY_anti_brute_force_threshold_kebab: return tr_sessionGetAntiBruteForceThreshold(&session); case TR_KEY_blocklist_enabled: - case TR_KEY_blocklist_enabled_kebab: return session.blocklist_enabled(); case TR_KEY_blocklist_size: - case TR_KEY_blocklist_size_kebab: return tr_blocklistGetRuleCount(&session); case TR_KEY_blocklist_url: - case TR_KEY_blocklist_url_kebab: return session.blocklistUrl(); case TR_KEY_cache_size_mb: - case TR_KEY_cache_size_mb_kebab: return tr_sessionGetCacheLimit_MB(&session); case TR_KEY_config_dir: - case TR_KEY_config_dir_kebab: return session.configDir(); case TR_KEY_default_trackers: - case TR_KEY_default_trackers_kebab: return session.defaultTrackersStr(); case TR_KEY_dht_enabled: - case TR_KEY_dht_enabled_kebab: return session.allowsDHT(); case TR_KEY_download_dir: - case TR_KEY_download_dir_kebab: return session.downloadDir(); case TR_KEY_download_dir_free_space: - case TR_KEY_download_dir_free_space_kebab: return tr_sys_path_get_capacity(session.downloadDir()).value_or(tr_sys_path_capacity{}).free; case TR_KEY_download_queue_enabled: - case TR_KEY_download_queue_enabled_kebab: return session.queueEnabled(TR_DOWN); case TR_KEY_download_queue_size: - case TR_KEY_download_queue_size_kebab: return session.queueSize(TR_DOWN); case TR_KEY_encryption: return tr_variant::unmanaged_string(getEncryptionModeString(tr_sessionGetEncryption(&session))); case TR_KEY_idle_seeding_limit: - case TR_KEY_idle_seeding_limit_kebab: return session.idleLimitMinutes(); case TR_KEY_idle_seeding_limit_enabled: - case TR_KEY_idle_seeding_limit_enabled_kebab: return session.isIdleLimited(); case TR_KEY_incomplete_dir: - case TR_KEY_incomplete_dir_kebab: return session.incompleteDir(); case TR_KEY_incomplete_dir_enabled: - case TR_KEY_incomplete_dir_enabled_kebab: return session.useIncompleteDir(); case TR_KEY_lpd_enabled: - case TR_KEY_lpd_enabled_kebab: return session.allowsLPD(); case TR_KEY_peer_limit_global: - case TR_KEY_peer_limit_global_kebab: return session.peerLimit(); case TR_KEY_peer_limit_per_torrent: - case TR_KEY_peer_limit_per_torrent_kebab: return session.peerLimitPerTorrent(); case TR_KEY_peer_port: - case TR_KEY_peer_port_kebab: return session.advertisedPeerPort().host(); case TR_KEY_peer_port_random_on_start: - case TR_KEY_peer_port_random_on_start_kebab: return session.isPortRandom(); case TR_KEY_pex_enabled: - case TR_KEY_pex_enabled_kebab: return session.allows_pex(); case TR_KEY_port_forwarding_enabled: - case TR_KEY_port_forwarding_enabled_kebab: return tr_sessionIsPortForwardingEnabled(&session); case TR_KEY_preferred_transports: return session.save_preferred_transports(); case TR_KEY_queue_stalled_enabled: - case TR_KEY_queue_stalled_enabled_kebab: return session.queueStalledEnabled(); case TR_KEY_queue_stalled_minutes: - case TR_KEY_queue_stalled_minutes_kebab: return session.queueStalledMinutes(); case TR_KEY_rename_partial_files: - case TR_KEY_rename_partial_files_kebab: return session.isIncompleteFileNamingEnabled(); case TR_KEY_reqq: return session.reqq(); case TR_KEY_rpc_version: - case TR_KEY_rpc_version_kebab: return RpcVersion; case TR_KEY_rpc_version_minimum: - case TR_KEY_rpc_version_minimum_kebab: return RpcVersionMin; case TR_KEY_rpc_version_semver: - case TR_KEY_rpc_version_semver_kebab: return tr_variant::unmanaged_string(TrRpcVersionSemver); case TR_KEY_script_torrent_added_enabled: - case TR_KEY_script_torrent_added_enabled_kebab: return session.useScript(TR_SCRIPT_ON_TORRENT_ADDED); case TR_KEY_script_torrent_added_filename: - case TR_KEY_script_torrent_added_filename_kebab: return session.script(TR_SCRIPT_ON_TORRENT_ADDED); case TR_KEY_script_torrent_done_enabled: - case TR_KEY_script_torrent_done_enabled_kebab: return session.useScript(TR_SCRIPT_ON_TORRENT_DONE); case TR_KEY_script_torrent_done_filename: - case TR_KEY_script_torrent_done_filename_kebab: return session.script(TR_SCRIPT_ON_TORRENT_DONE); case TR_KEY_script_torrent_done_seeding_enabled: - case TR_KEY_script_torrent_done_seeding_enabled_kebab: return session.useScript(TR_SCRIPT_ON_TORRENT_DONE_SEEDING); case TR_KEY_script_torrent_done_seeding_filename: - case TR_KEY_script_torrent_done_seeding_filename_kebab: return session.script(TR_SCRIPT_ON_TORRENT_DONE_SEEDING); case TR_KEY_seed_ratio_limit: - case TR_KEY_seed_ratio_limit_camel: return session.desiredRatio(); case TR_KEY_seed_ratio_limited: - case TR_KEY_seed_ratio_limited_camel: return session.isRatioLimited(); case TR_KEY_seed_queue_enabled: - case TR_KEY_seed_queue_enabled_kebab: return session.queueEnabled(TR_UP); case TR_KEY_seed_queue_size: - case TR_KEY_seed_queue_size_kebab: return session.queueSize(TR_UP); case TR_KEY_sequential_download: return session.sequential_download(); case TR_KEY_session_id: - case TR_KEY_session_id_kebab: return session.sessionId(); case TR_KEY_speed_limit_down: - case TR_KEY_speed_limit_down_kebab: return session.speed_limit(TR_DOWN).count(Speed::Units::KByps); case TR_KEY_speed_limit_down_enabled: - case TR_KEY_speed_limit_down_enabled_kebab: return session.is_speed_limited(TR_DOWN); case TR_KEY_speed_limit_up: - case TR_KEY_speed_limit_up_kebab: return session.speed_limit(TR_UP).count(Speed::Units::KByps); case TR_KEY_speed_limit_up_enabled: - case TR_KEY_speed_limit_up_enabled_kebab: return session.is_speed_limited(TR_UP); case TR_KEY_start_added_torrents: - case TR_KEY_start_added_torrents_kebab: return !session.shouldPauseAddedTorrents(); case TR_KEY_tcp_enabled: - case TR_KEY_tcp_enabled_kebab: return session.allowsTCP(); case TR_KEY_trash_original_torrent_files: - case TR_KEY_trash_original_torrent_files_kebab: return session.shouldDeleteSource(); case TR_KEY_units: return values_get_units(); case TR_KEY_utp_enabled: - case TR_KEY_utp_enabled_kebab: return session.allowsUTP(); case TR_KEY_version: return LONG_VERSION_STRING; @@ -2833,7 +2542,6 @@ namespace session_get_helpers // response args_out.try_emplace(TR_KEY_path, *path); args_out.try_emplace(TR_KEY_size_bytes, capacity ? capacity->free : -1); - args_out.try_emplace(TR_KEY_size_bytes_kebab, capacity ? capacity->free : -1); args_out.try_emplace(TR_KEY_total_size, capacity ? capacity->total : -1); if (error) @@ -2881,7 +2589,7 @@ auto const sync_handlers = small::max_size_map, 4U>{ { { TR_KEY_blocklist_update, { blocklistUpdate, true } }, @@ -2894,7 +2602,7 @@ void noop_response_callback(tr_session* /*session*/, tr_variant&& /*response*/) { } -void tr_rpc_request_exec_impl(tr_session* session, tr_variant const& request, tr_rpc_response_func&& callback, bool is_batch) +void tr_rpc_request_exec_impl(tr_session* session, tr_variant& request, tr_rpc_response_func&& callback, bool is_batch) { using namespace JsonRpc; @@ -2903,7 +2611,7 @@ void tr_rpc_request_exec_impl(tr_session* session, tr_variant const& request, tr callback = noop_response_callback; } - auto const* const map = request.get_if(); + auto const* map = request.get_if(); if (map == nullptr) { callback( @@ -2927,60 +2635,63 @@ void tr_rpc_request_exec_impl(tr_session* session, tr_variant const& request, tr build_response(Error::INVALID_REQUEST, nullptr, Error::build_data("JSON-RPC version is not 2.0"sv, {}))); return; } + else + { + libtransmission::api_compat::convert_incoming_data(request); + map = request.get_if(); + TR_ASSERT(map != nullptr); + if (map == nullptr) + { + auto response = tr_variant::Map{ 2U }; + response.try_emplace(TR_KEY_arguments, tr_variant::Map{}); + response.try_emplace( + TR_KEY_result, + tr_variant::unmanaged_string( + "bug in api-compat, please report a bug at https://github.com/transmission/transmission/issues"sv)); + callback(session, std::move(response)); + return; + } + } auto const empty_params = tr_variant::Map{}; - auto const* params = map->find_if(is_jsonrpc ? TR_KEY_params : TR_KEY_arguments); + auto const* params = map->find_if(TR_KEY_params); if (params == nullptr) { params = &empty_params; } auto const method_name = map->value_if(TR_KEY_method).value_or(""sv); - auto const method_key = tr_quark_convert(tr_quark_new(method_name)); + auto const method_key = tr_quark_new(method_name); - auto data = tr_rpc_idle_data{}; - data.session = session; + auto* const data = new tr_rpc_idle_data{}; + data->session = session; + data->is_jsonrpc = is_jsonrpc; + data->callback = std::move(callback); - if (auto iter = map->find(is_jsonrpc ? TR_KEY_id : TR_KEY_tag); iter != std::end(*map)) + if (auto iter = map->find(TR_KEY_id); iter != std::end(*map)) { tr_variant const& id = iter->second; - if (is_jsonrpc && !is_valid_id(id)) + if (!is_valid_id(id)) { - callback( - session, - build_response( - Error::INVALID_REQUEST, - nullptr, - Error::build_data("id type must be String, Number, or Null"sv, {}))); + data->id = nullptr; + tr_rpc_idle_done(data, Error::INVALID_REQUEST, "id type must be String, Number, or Null"sv); return; } - data.id.merge(id); + data->id.merge(id); } - data.callback = std::move(callback); - - auto const is_notification = is_jsonrpc && !data.id.has_value(); - - auto done_cb = is_jsonrpc ? tr_rpc_idle_done : tr_rpc_idle_done_legacy; + auto const is_notification = is_jsonrpc && !data->id.has_value(); if (auto const handler = async_handlers.find(method_key); handler != std::end(async_handlers)) { auto const& [func, has_side_effects] = handler->second; if (is_notification && !has_side_effects) { - done_cb(&data, Error::SUCCESS, {}); + tr_rpc_idle_done(data, Error::SUCCESS, {}); return; } - func( - session, - *params, - [cb = std::move(done_cb)](tr_rpc_idle_data* d, Error::Code code, std::string_view errmsg) - { - cb(d, code, errmsg); - delete d; - }, - new tr_rpc_idle_data{ std::move(data) }); + func(session, *params, data); return; } @@ -2989,20 +2700,20 @@ void tr_rpc_request_exec_impl(tr_session* session, tr_variant const& request, tr auto const& [func, has_side_effects] = handler->second; if (is_notification && !has_side_effects) { - done_cb(&data, Error::SUCCESS, {}); + tr_rpc_idle_done(data, Error::SUCCESS, {}); return; } - auto const [err, errmsg] = func(session, *params, data.args_out); - done_cb(&data, err, errmsg); + auto const [err, errmsg] = func(session, *params, data->args_out); + tr_rpc_idle_done(data, err, errmsg); return; } // couldn't find a handler - done_cb(&data, Error::METHOD_NOT_FOUND, is_jsonrpc ? ""sv : "no method name"sv); + tr_rpc_idle_done(data, Error::METHOD_NOT_FOUND, {}); } -void tr_rpc_request_exec_batch(tr_session* session, tr_variant::Vector const& requests, tr_rpc_response_func&& callback) +void tr_rpc_request_exec_batch(tr_session* session, tr_variant::Vector& requests, tr_rpc_response_func&& callback) { auto const n_requests = std::size(requests); auto responses = std::make_shared(n_requests); @@ -3036,11 +2747,12 @@ void tr_rpc_request_exec_batch(tr_session* session, tr_variant::Vector const& re } // namespace -void tr_rpc_request_exec(tr_session* session, tr_variant const& request, tr_rpc_response_func&& callback) +// TODO(tearfur): take `tr_variant const& request` after removing api_compat +void tr_rpc_request_exec(tr_session* session, tr_variant& request, tr_rpc_response_func&& callback) { auto const lock = session->unique_lock(); - if (auto const* const vec = request.get_if(); vec != nullptr) + if (auto* const vec = request.get_if(); vec != nullptr) { tr_rpc_request_exec_batch(session, *vec, std::move(callback)); return; diff --git a/libtransmission/rpcimpl.h b/libtransmission/rpcimpl.h index 427899c47..df253c142 100644 --- a/libtransmission/rpcimpl.h +++ b/libtransmission/rpcimpl.h @@ -50,6 +50,6 @@ enum Code : int16_t using tr_rpc_response_func = std::function; -void tr_rpc_request_exec(tr_session* session, tr_variant const& request, tr_rpc_response_func&& callback = {}); +void tr_rpc_request_exec(tr_session* session, tr_variant& request, tr_rpc_response_func&& callback = {}); void tr_rpc_request_exec(tr_session* session, std::string_view request, tr_rpc_response_func&& callback = {}); diff --git a/libtransmission/session.h b/libtransmission/session.h index ff3651f40..2a6b601a9 100644 --- a/libtransmission/session.h +++ b/libtransmission/session.h @@ -1298,13 +1298,13 @@ private: public: /// constexpr fields - static constexpr std::array, 3> Scripts{ - { { TR_KEY_script_torrent_added_enabled_kebab, TR_KEY_script_torrent_added_filename_kebab, TR_SCRIPT_ON_TORRENT_ADDED }, - { TR_KEY_script_torrent_done_enabled_kebab, TR_KEY_script_torrent_done_filename_kebab, TR_SCRIPT_ON_TORRENT_DONE }, - { TR_KEY_script_torrent_done_seeding_enabled_kebab, - TR_KEY_script_torrent_done_seeding_filename_kebab, - TR_SCRIPT_ON_TORRENT_DONE_SEEDING } } - }; + static constexpr std::array, 3> Scripts{ { + { TR_KEY_script_torrent_added_enabled, TR_KEY_script_torrent_added_filename, TR_SCRIPT_ON_TORRENT_ADDED }, + { TR_KEY_script_torrent_done_enabled, TR_KEY_script_torrent_done_filename, TR_SCRIPT_ON_TORRENT_DONE }, + { TR_KEY_script_torrent_done_seeding_enabled, + TR_KEY_script_torrent_done_seeding_filename, + TR_SCRIPT_ON_TORRENT_DONE_SEEDING }, + } }; private: /// const fields diff --git a/qt/RpcClient.cc b/qt/RpcClient.cc index 21d7b4ba1..e2d6d1755 100644 --- a/qt/RpcClient.cc +++ b/qt/RpcClient.cc @@ -147,7 +147,7 @@ void RpcClient::sendNetworkRequest(QByteArray const& body, QFutureInterface const& promise, int64_t const id) +void RpcClient::sendLocalRequest(tr_variant& req, QFutureInterface const& promise, int64_t const id) { if (verbose_) { diff --git a/qt/RpcClient.h b/qt/RpcClient.h index 758869eba..3eeb13595 100644 --- a/qt/RpcClient.h +++ b/qt/RpcClient.h @@ -89,7 +89,7 @@ private: QNetworkAccessManager* networkAccessManager(); void sendNetworkRequest(QByteArray const& body, QFutureInterface const& promise); - void sendLocalRequest(tr_variant const& req, QFutureInterface const& promise, int64_t id); + void sendLocalRequest(tr_variant& req, QFutureInterface const& promise, int64_t id); [[nodiscard]] int64_t parseResponseId(tr_variant& response) const; [[nodiscard]] RpcResponse parseResponseData(tr_variant& response) const; diff --git a/tests/libtransmission/api-compat-test.cc b/tests/libtransmission/api-compat-test.cc index e1cf94425..079b1515e 100644 --- a/tests/libtransmission/api-compat-test.cc +++ b/tests/libtransmission/api-compat-test.cc @@ -645,6 +645,16 @@ constexpr std::string_view UnrecognisedInfoLegacyResponse = R"json({ "tag": 10 })json"; +constexpr std::string_view LegacyNonIntTagRequest = R"json({ + "method": "session-get", + "tag": "0" +})json"; + +constexpr std::string_view LegacyNonIntTagRequestResult = R"json({ + "jsonrpc": "2.0", + "method": "session_get" +})json"; + // clang-format off constexpr std::string_view LegacyResumeBenc = "d" @@ -953,7 +963,7 @@ TEST_F(ApiCompatTest, canConvertRpc) using TestCase = std::tuple; // clang-format off - static auto constexpr TestCases = std::array{ { + static auto constexpr TestCases = std::array{ { { "free_space tr5 -> tr5", BadFreeSpaceRequest, Style::Tr5, BadFreeSpaceRequest }, { "free_space tr5 -> tr4", BadFreeSpaceRequest, Style::Tr4, BadFreeSpaceRequestLegacy }, { "free_space tr4 -> tr5", BadFreeSpaceRequestLegacy, Style::Tr5, BadFreeSpaceRequest }, @@ -994,6 +1004,8 @@ TEST_F(ApiCompatTest, canConvertRpc) { "unrecognised info tr5 -> tr4", UnrecognisedInfoResponse, Style::Tr4, UnrecognisedInfoLegacyResponse}, { "unrecognised info tr4 -> tr5", UnrecognisedInfoLegacyResponse, Style::Tr5, UnrecognisedInfoResponse}, { "unrecognised info tr4 -> tr4", UnrecognisedInfoLegacyResponse, Style::Tr4, UnrecognisedInfoLegacyResponse}, + { "non-int tag tr4 -> tr5", LegacyNonIntTagRequest, Style::Tr5, LegacyNonIntTagRequestResult }, + { "non-int tag tr4 -> tr4", LegacyNonIntTagRequest, Style::Tr4, LegacyNonIntTagRequest }, // TODO(ckerr): torrent-get with 'table' } }; diff --git a/tests/libtransmission/rpc-test.cc b/tests/libtransmission/rpc-test.cc index 3bd6ce1f0..833f0dc0e 100644 --- a/tests/libtransmission/rpc-test.cc +++ b/tests/libtransmission/rpc-test.cc @@ -36,7 +36,7 @@ namespace { auto serde = tr_variant_serde::json().inplace(); - auto const request = serde.parse(jsonreq); + auto request = serde.parse(jsonreq); if (!request) { return {}; @@ -45,7 +45,7 @@ namespace auto response = tr_variant{}; tr_rpc_request_exec( session, - std::move(*request), + *request, [&response](tr_session* /*session*/, tr_variant&& resp) { response = std::move(resp); }); return serde.to_string(response); @@ -87,7 +87,7 @@ TEST_F(RpcTest, NotArrayOrObject) requests.emplace_back(nullptr); requests.emplace_back(true); - for (auto const& req : requests) + for (auto& req : requests) { auto response = tr_variant{}; tr_rpc_request_exec( @@ -123,11 +123,12 @@ TEST_F(RpcTest, JsonRpcWrongVersion) request_map.try_emplace(TR_KEY_jsonrpc, "1.0"); request_map.try_emplace(TR_KEY_method, tr_variant::unmanaged_string(TR_KEY_session_stats)); request_map.try_emplace(TR_KEY_id, 12345); + auto request = tr_variant{ std::move(request_map) }; auto response = tr_variant{}; tr_rpc_request_exec( session_, - std::move(request_map), + request, [&response](tr_session* /*session*/, tr_variant&& resp) { response = std::move(resp); }); auto const* const response_map = response.get_if(); @@ -163,13 +164,14 @@ TEST_F(RpcTest, idSync) { auto request_map = tr_variant::Map{ 3U }; request_map.try_emplace(TR_KEY_jsonrpc, JsonRpc::Version); - request_map.try_emplace(TR_KEY_method, tr_variant::unmanaged_string(TR_KEY_session_stats_kebab)); + request_map.try_emplace(TR_KEY_method, tr_variant::unmanaged_string(TR_KEY_session_stats)); request_map[TR_KEY_id].merge(request_id); // copy + auto request = tr_variant{ std::move(request_map) }; auto response = tr_variant{}; tr_rpc_request_exec( session_, - std::move(request_map), + request, [&response](tr_session* /*session*/, tr_variant&& resp) { response = std::move(resp); }); auto const* const response_map = response.get_if(); @@ -212,11 +214,12 @@ TEST_F(RpcTest, idWrongType) request_map.try_emplace(TR_KEY_jsonrpc, JsonRpc::Version); request_map.try_emplace(TR_KEY_method, tr_variant::unmanaged_string(TR_KEY_session_stats)); request_map[TR_KEY_id].merge(request_id); // copy + auto request = tr_variant{ std::move(request_map) }; auto response = tr_variant{}; tr_rpc_request_exec( session_, - std::move(request_map), + request, [&response](tr_session* /*session*/, tr_variant&& resp) { response = std::move(resp); }); auto const* const response_map = response.get_if(); @@ -246,11 +249,12 @@ TEST_F(RpcTest, tagSyncLegacy) auto request_map = tr_variant::Map{ 2U }; request_map.try_emplace(TR_KEY_method, tr_variant::unmanaged_string(TR_KEY_session_stats)); request_map.try_emplace(TR_KEY_tag, 12345); + auto request = tr_variant{ std::move(request_map) }; auto response = tr_variant{}; tr_rpc_request_exec( session_, - std::move(request_map), + request, [&response](tr_session* /*session*/, tr_variant&& resp) { response = std::move(resp); }); auto const* const response_map = response.get_if(); @@ -278,7 +282,7 @@ TEST_F(RpcTest, idAsync) auto request_map = tr_variant::Map{ 3U }; request_map.try_emplace(TR_KEY_jsonrpc, JsonRpc::Version); - request_map.try_emplace(TR_KEY_method, tr_variant::unmanaged_string(TR_KEY_torrent_rename_path_kebab)); + request_map.try_emplace(TR_KEY_method, tr_variant::unmanaged_string(TR_KEY_torrent_rename_path)); request_map[TR_KEY_id].merge(request_id); // copy auto params_map = tr_variant::Map{ 2U }; @@ -286,11 +290,12 @@ TEST_F(RpcTest, idAsync) params_map.try_emplace(TR_KEY_name, "512_test"); request_map.try_emplace(TR_KEY_params, std::move(params_map)); + auto request = tr_variant{ std::move(request_map) }; auto promise = std::promise{}; auto future = promise.get_future(); tr_rpc_request_exec( session_, - std::move(request_map), + request, [&promise](tr_session* /*session*/, tr_variant&& resp) { promise.set_value(std::move(resp)); }); auto const response = future.get(); @@ -338,11 +343,12 @@ TEST_F(RpcTest, tagAsyncLegacy) arguments_map.try_emplace(TR_KEY_name, "512_test"); request_map.try_emplace(TR_KEY_arguments, std::move(arguments_map)); + auto request = tr_variant{ std::move(request_map) }; auto promise = std::promise{}; auto future = promise.get_future(); tr_rpc_request_exec( session_, - std::move(request_map), + request, [&promise](tr_session* /*session*/, tr_variant&& resp) { promise.set_value(std::move(resp)); }); auto const response = future.get(); @@ -364,11 +370,12 @@ TEST_F(RpcTest, NotificationSync) auto request_map = tr_variant::Map{ 2U }; request_map.try_emplace(TR_KEY_jsonrpc, JsonRpc::Version); request_map.try_emplace(TR_KEY_method, tr_variant::unmanaged_string(TR_KEY_session_stats)); + auto request = tr_variant{ std::move(request_map) }; auto response = tr_variant{}; tr_rpc_request_exec( session_, - std::move(request_map), + request, [&response](tr_session* /*session*/, tr_variant&& resp) { response = std::move(resp); }); EXPECT_FALSE(response.has_value()); @@ -388,11 +395,12 @@ TEST_F(RpcTest, NotificationAsync) params_map.try_emplace(TR_KEY_name, "512_test"); request_map.try_emplace(TR_KEY_params, std::move(params_map)); + auto request = tr_variant{ std::move(request_map) }; auto promise = std::promise{}; auto future = promise.get_future(); tr_rpc_request_exec( session_, - std::move(request_map), + request, [&promise](tr_session* /*session*/, tr_variant&& resp) { promise.set_value(std::move(resp)); }); auto const response = future.get(); @@ -408,11 +416,12 @@ TEST_F(RpcTest, tagNoHandler) request_map.try_emplace(TR_KEY_jsonrpc, JsonRpc::Version); request_map.try_emplace(TR_KEY_method, "sdgdhsgg"); request_map.try_emplace(TR_KEY_id, 12345); + auto request = tr_variant{ std::move(request_map) }; auto response = tr_variant{}; tr_rpc_request_exec( session_, - std::move(request_map), + request, [&response](tr_session* /*session*/, tr_variant&& resp) { response = std::move(resp); }); auto const* const response_map = response.get_if(); @@ -440,11 +449,12 @@ TEST_F(RpcTest, tagNoHandlerLegacy) auto request_map = tr_variant::Map{ 2U }; request_map.try_emplace(TR_KEY_method, "sdgdhsgg"); request_map.try_emplace(TR_KEY_tag, 12345); + auto request = tr_variant{ std::move(request_map) }; auto response = tr_variant{}; tr_rpc_request_exec( session_, - std::move(request_map), + request, [&response](tr_session* /*session*/, tr_variant&& resp) { response = std::move(resp); }); auto const* const response_map = response.get_if(); @@ -462,49 +472,50 @@ TEST_F(RpcTest, batch) auto request_vec = tr_variant::Vector{}; request_vec.reserve(8U); - auto request = tr_variant::Map{ 3U }; - request.try_emplace(TR_KEY_jsonrpc, JsonRpc::Version); - request.try_emplace(TR_KEY_method, tr_variant::unmanaged_string(TR_KEY_session_stats_kebab)); - request.try_emplace(TR_KEY_id, 12345); - request_vec.emplace_back(std::move(request)); + auto request_map = tr_variant::Map{ 3U }; + request_map.try_emplace(TR_KEY_jsonrpc, JsonRpc::Version); + request_map.try_emplace(TR_KEY_method, tr_variant::unmanaged_string(TR_KEY_session_stats)); + request_map.try_emplace(TR_KEY_id, 12345); + request_vec.emplace_back(std::move(request_map)); - request = tr_variant::Map{ 2U }; - request.try_emplace(TR_KEY_jsonrpc, JsonRpc::Version); - request.try_emplace(TR_KEY_method, tr_variant::unmanaged_string(TR_KEY_session_set_kebab)); - request_vec.emplace_back(std::move(request)); + request_map = tr_variant::Map{ 2U }; + request_map.try_emplace(TR_KEY_jsonrpc, JsonRpc::Version); + request_map.try_emplace(TR_KEY_method, tr_variant::unmanaged_string(TR_KEY_session_set)); + request_vec.emplace_back(std::move(request_map)); - request = tr_variant::Map{ 3U }; - request.try_emplace(TR_KEY_jsonrpc, JsonRpc::Version); - request.try_emplace(TR_KEY_method, tr_variant::unmanaged_string(TR_KEY_session_stats_kebab)); - request.try_emplace(TR_KEY_id, "12345"sv); - request_vec.emplace_back(std::move(request)); + request_map = tr_variant::Map{ 3U }; + request_map.try_emplace(TR_KEY_jsonrpc, JsonRpc::Version); + request_map.try_emplace(TR_KEY_method, tr_variant::unmanaged_string(TR_KEY_session_stats)); + request_map.try_emplace(TR_KEY_id, "12345"sv); + request_vec.emplace_back(std::move(request_map)); - request = tr_variant::Map{ 1U }; - request.try_emplace(tr_quark_new("foo"sv), "boo"sv); - request_vec.emplace_back(std::move(request)); + request_map = tr_variant::Map{ 1U }; + request_map.try_emplace(tr_quark_new("foo"sv), "boo"sv); + request_vec.emplace_back(std::move(request_map)); request_vec.emplace_back(1); - request = tr_variant::Map{ 3U }; - request.try_emplace(TR_KEY_jsonrpc, JsonRpc::Version); - request.try_emplace(TR_KEY_method, "dnfsojnsdkjf"); - request.try_emplace(TR_KEY_id, 12345); - request_vec.emplace_back(std::move(request)); + request_map = tr_variant::Map{ 3U }; + request_map.try_emplace(TR_KEY_jsonrpc, JsonRpc::Version); + request_map.try_emplace(TR_KEY_method, "dnfsojnsdkjf"); + request_map.try_emplace(TR_KEY_id, 12345); + request_vec.emplace_back(std::move(request_map)); - request = tr_variant::Map{ 1U }; - request.try_emplace(TR_KEY_jsonrpc, JsonRpc::Version); - request.try_emplace(TR_KEY_method, "dnfsojnsdkjf"); - request_vec.emplace_back(std::move(request)); + request_map = tr_variant::Map{ 1U }; + request_map.try_emplace(TR_KEY_jsonrpc, JsonRpc::Version); + request_map.try_emplace(TR_KEY_method, "dnfsojnsdkjf"); + request_vec.emplace_back(std::move(request_map)); - request = tr_variant::Map{ 2U }; - request.try_emplace(TR_KEY_method, tr_variant::unmanaged_string(TR_KEY_session_stats_kebab)); - request.try_emplace(TR_KEY_tag, 12345); - request_vec.emplace_back(std::move(request)); + request_map = tr_variant::Map{ 2U }; + request_map.try_emplace(TR_KEY_method, tr_variant::unmanaged_string(TR_KEY_session_stats)); + request_map.try_emplace(TR_KEY_tag, 12345); + request_vec.emplace_back(std::move(request_map)); + auto request = tr_variant{ std::move(request_vec) }; auto response = tr_variant{}; tr_rpc_request_exec( session_, - std::move(request_vec), + request, [&response](tr_session* /*session*/, tr_variant&& resp) { response = std::move(resp); }); auto* const response_vec_ptr = response.get_if(); @@ -618,10 +629,12 @@ TEST_F(RpcTest, sessionGet) request_map.try_emplace(TR_KEY_jsonrpc, JsonRpc::Version); request_map.try_emplace(TR_KEY_method, tr_variant::unmanaged_string(TR_KEY_session_get)); request_map.try_emplace(TR_KEY_id, 12345); + auto request = tr_variant{ std::move(request_map) }; + auto response = tr_variant{}; tr_rpc_request_exec( session_, - std::move(request_map), + request, [&response](tr_session* /*session*/, tr_variant&& resp) { response = std::move(resp); }); auto* response_map = response.get_if(); @@ -631,13 +644,6 @@ TEST_F(RpcTest, sessionGet) // what we expected static auto constexpr ExpectedKeysUnsorted = std::array{ - TR_KEY_alt_speed_down_kebab, - TR_KEY_alt_speed_enabled_kebab, - TR_KEY_alt_speed_time_begin_kebab, - TR_KEY_alt_speed_time_day_kebab, - TR_KEY_alt_speed_time_enabled_kebab, - TR_KEY_alt_speed_time_end_kebab, - TR_KEY_alt_speed_up_kebab, TR_KEY_alt_speed_down, TR_KEY_alt_speed_enabled, TR_KEY_alt_speed_time_begin, @@ -645,108 +651,59 @@ TEST_F(RpcTest, sessionGet) TR_KEY_alt_speed_time_enabled, TR_KEY_alt_speed_time_end, TR_KEY_alt_speed_up, - TR_KEY_anti_brute_force_enabled_kebab, - TR_KEY_anti_brute_force_threshold_kebab, TR_KEY_anti_brute_force_enabled, TR_KEY_anti_brute_force_threshold, - TR_KEY_blocklist_enabled_kebab, - TR_KEY_blocklist_size_kebab, - TR_KEY_blocklist_url_kebab, TR_KEY_blocklist_enabled, TR_KEY_blocklist_size, TR_KEY_blocklist_url, - TR_KEY_cache_size_mb_kebab, TR_KEY_cache_size_mb, - TR_KEY_config_dir_kebab, TR_KEY_config_dir, - TR_KEY_default_trackers_kebab, TR_KEY_default_trackers, - TR_KEY_dht_enabled_kebab, TR_KEY_dht_enabled, - TR_KEY_download_dir_kebab, - TR_KEY_download_dir_free_space_kebab, - TR_KEY_download_queue_enabled_kebab, - TR_KEY_download_queue_size_kebab, TR_KEY_download_dir, TR_KEY_download_dir_free_space, TR_KEY_download_queue_enabled, TR_KEY_download_queue_size, TR_KEY_encryption, - TR_KEY_idle_seeding_limit_kebab, - TR_KEY_idle_seeding_limit_enabled_kebab, TR_KEY_idle_seeding_limit, TR_KEY_idle_seeding_limit_enabled, - TR_KEY_incomplete_dir_kebab, - TR_KEY_incomplete_dir_enabled_kebab, TR_KEY_incomplete_dir, TR_KEY_incomplete_dir_enabled, - TR_KEY_lpd_enabled_kebab, TR_KEY_lpd_enabled, - TR_KEY_peer_limit_global_kebab, - TR_KEY_peer_limit_per_torrent_kebab, - TR_KEY_peer_port_kebab, - TR_KEY_peer_port_random_on_start_kebab, TR_KEY_peer_limit_global, TR_KEY_peer_limit_per_torrent, TR_KEY_peer_port, TR_KEY_peer_port_random_on_start, - TR_KEY_pex_enabled_kebab, TR_KEY_pex_enabled, - TR_KEY_port_forwarding_enabled_kebab, TR_KEY_port_forwarding_enabled, TR_KEY_preferred_transports, - TR_KEY_queue_stalled_enabled_kebab, - TR_KEY_queue_stalled_minutes_kebab, TR_KEY_queue_stalled_enabled, TR_KEY_queue_stalled_minutes, - TR_KEY_rename_partial_files_kebab, TR_KEY_rename_partial_files, TR_KEY_reqq, - TR_KEY_rpc_version_kebab, - TR_KEY_rpc_version_minimum_kebab, - TR_KEY_rpc_version_semver_kebab, TR_KEY_rpc_version, TR_KEY_rpc_version_minimum, TR_KEY_rpc_version_semver, - TR_KEY_script_torrent_added_enabled_kebab, - TR_KEY_script_torrent_added_filename_kebab, - TR_KEY_script_torrent_done_enabled_kebab, - TR_KEY_script_torrent_done_filename_kebab, - TR_KEY_script_torrent_done_seeding_enabled_kebab, - TR_KEY_script_torrent_done_seeding_filename_kebab, TR_KEY_script_torrent_added_enabled, TR_KEY_script_torrent_added_filename, TR_KEY_script_torrent_done_enabled, TR_KEY_script_torrent_done_filename, TR_KEY_script_torrent_done_seeding_enabled, TR_KEY_script_torrent_done_seeding_filename, - TR_KEY_seed_queue_enabled_kebab, - TR_KEY_seed_queue_size_kebab, - TR_KEY_seed_ratio_limit_camel, - TR_KEY_seed_ratio_limited_camel, TR_KEY_seed_queue_enabled, TR_KEY_seed_queue_size, TR_KEY_seed_ratio_limit, TR_KEY_seed_ratio_limited, TR_KEY_sequential_download, - TR_KEY_session_id_kebab, TR_KEY_session_id, - TR_KEY_speed_limit_down_kebab, - TR_KEY_speed_limit_down_enabled_kebab, - TR_KEY_speed_limit_up_kebab, - TR_KEY_speed_limit_up_enabled_kebab, TR_KEY_speed_limit_down, TR_KEY_speed_limit_down_enabled, TR_KEY_speed_limit_up, TR_KEY_speed_limit_up_enabled, - TR_KEY_start_added_torrents_kebab, TR_KEY_start_added_torrents, - TR_KEY_tcp_enabled_kebab, TR_KEY_tcp_enabled, - TR_KEY_trash_original_torrent_files_kebab, TR_KEY_trash_original_torrent_files, TR_KEY_units, - TR_KEY_utp_enabled_kebab, TR_KEY_utp_enabled, TR_KEY_version, }; @@ -787,22 +744,23 @@ TEST_F(RpcTest, torrentGet) auto* tor = zeroTorrentInit(ZeroTorrentState::NoFiles); EXPECT_NE(nullptr, tor); - auto request = tr_variant::Map{ 3U }; + auto request_map = tr_variant::Map{ 3U }; - request.try_emplace(TR_KEY_jsonrpc, JsonRpc::Version); - request.try_emplace(TR_KEY_method, tr_variant::unmanaged_string(TR_KEY_torrent_get)); - request.try_emplace(TR_KEY_id, 12345); + request_map.try_emplace(TR_KEY_jsonrpc, JsonRpc::Version); + request_map.try_emplace(TR_KEY_method, tr_variant::unmanaged_string(TR_KEY_torrent_get)); + request_map.try_emplace(TR_KEY_id, 12345); auto params = tr_variant::Map{ 1U }; auto fields = tr_variant::Vector{}; fields.emplace_back(tr_quark_get_string_view(TR_KEY_id)); params.try_emplace(TR_KEY_fields, std::move(fields)); - request.try_emplace(TR_KEY_params, std::move(params)); + request_map.try_emplace(TR_KEY_params, std::move(params)); + auto request = tr_variant{ std::move(request_map) }; auto response = tr_variant{}; tr_rpc_request_exec( session_, - std::move(request), + request, [&response](tr_session* /*session*/, tr_variant&& resp) { response = std::move(resp); }); auto* response_map = response.get_if(); @@ -829,20 +787,21 @@ TEST_F(RpcTest, torrentGetLegacy) auto* tor = zeroTorrentInit(ZeroTorrentState::NoFiles); EXPECT_NE(nullptr, tor); - auto request = tr_variant::Map{ 1U }; + auto request_map = tr_variant::Map{ 1U }; - request.try_emplace(TR_KEY_method, tr_quark_get_string_view(TR_KEY_torrent_get_kebab)); + request_map.try_emplace(TR_KEY_method, tr_quark_get_string_view(TR_KEY_torrent_get_kebab)); auto args_in = tr_variant::Map{ 1U }; auto fields = tr_variant::Vector{}; fields.emplace_back(tr_quark_get_string_view(TR_KEY_id)); args_in.try_emplace(TR_KEY_fields, std::move(fields)); - request.try_emplace(TR_KEY_arguments, std::move(args_in)); + request_map.try_emplace(TR_KEY_arguments, std::move(args_in)); + auto request = tr_variant{ std::move(request_map) }; auto response = tr_variant{}; tr_rpc_request_exec( session_, - std::move(request), + request, [&response](tr_session* /*session*/, tr_variant&& resp) { response = std::move(resp); }); auto* response_map = response.get_if(); @@ -937,7 +896,6 @@ constexpr std::string_view WellFormedResponse = R"json({ "jsonrpc": "2.0", "result": { "path": ")json" RPC_NON_EXISTENT_PATH R"json(", - "size-bytes": -1, "size_bytes": -1, "total_size": -1 } @@ -963,7 +921,6 @@ constexpr std::string_view WellFormedLegacyResponse = R"json({ "arguments": { "path": ")json" RPC_NON_EXISTENT_PATH R"json(", "size-bytes": -1, - "size_bytes": -1, "total_size": -1 }, "result": "success",