CDRIVER-835 remove mongoc_client_kill_cursor (#1936)

* remove `mongoc_client_kill_cursor`
* remove unused code for `OP_KILL_CURSORS`

Author: kevinAlbs

NEWS

@@ -61,6 +61,20 @@ Instead, the names must be prefixed with the parent directory: `mongoc/mongoc.h`
 #include <mongoc/mongoc.h>
 ```
 
+### `mongoc_client_kill_cursor`
+
+`mongoc_client_kill_cursor` is removed. It did not accept a server identifier. It was only reliable when connected to a single server.
+
+Sending [killCursors](https://www.mongodb.com/docs/manual/reference/command/killCursors/) is not typically needed. `mongoc_cursor_t` manages the cursor lifetime. If needed, use a generic command helper to manually send a `killCursors` command:
+
+```c
+bson_t *cmd = BCON_NEW ("killCursors", "coll", "cursors", "[", BCON_INT64 (cursor_id), "]");
+bool ok = mongoc_client_command_simple_with_server_id (client, "db", cmd, NULL, server_id, NULL, &error);
+if (!ok) {
+  printf ("Failed to send 'killCursors': %s\n", error.message);
+}
+bson_destroy (cmd);
+```
 
 
 libmongoc 1.30.2

build/generate-future-functions.py

@@ -201,11 +201,6 @@
                      param("bson_ptr", "reply"),
                      param("bson_error_ptr", "error")]),
 
-    future_function("void",
-                    "mongoc_client_kill_cursor",
-                    [param("mongoc_client_ptr", "client"),
-                     param("int64_t", "cursor_id")]),
-
     future_function("mongoc_change_stream_ptr",
                     "mongoc_client_watch",
                     [param("mongoc_client_ptr", "client"),
@@ -573,7 +568,7 @@ def future_function_name(fn):
         # E.g. future_cursor_next().
         return 'future' + fn.name[len('mongoc'):]
     else:
-        # E.g. future__mongoc_client_kill_cursor().
+        # E.g. future_mongoc_client_command_simple().
         return 'future_' + fn.name
 
 

src/libmongoc/src/mongoc/mongoc-client.c

@@ -79,14 +79,6 @@
 #define MONGOC_LOG_DOMAIN "client"
 
 
-static void
-_mongoc_client_op_killcursors (mongoc_cluster_t *cluster,
-                               mongoc_server_stream_t *server_stream,
-                               int64_t cursor_id,
-                               int64_t operation_id,
-                               const char *db,
-                               const char *collection);
-
 static void
 _mongoc_client_killcursors_command (mongoc_cluster_t *cluster,
                                     mongoc_server_stream_t *server_stream,
@@ -2098,6 +2090,8 @@ _mongoc_client_kill_cursor (mongoc_client_t *client,
    ENTRY;
 
    BSON_ASSERT_PARAM (client);
+   BSON_ASSERT_PARAM (db);
+   BSON_ASSERT_PARAM (collection);
    BSON_ASSERT (cursor_id);
 
    /* don't attempt reconnect if server unavailable, and ignore errors */
@@ -2108,209 +2102,14 @@ _mongoc_client_kill_cursor (mongoc_client_t *client,
       return;
    }
 
-   if (db && collection) {
-      _mongoc_client_killcursors_command (&client->cluster, server_stream, cursor_id, db, collection, cs);
-   } else {
-      _mongoc_client_op_killcursors (&client->cluster, server_stream, cursor_id, operation_id, db, collection);
-   }
+   _mongoc_client_killcursors_command (&client->cluster, server_stream, cursor_id, db, collection, cs);
 
    mongoc_server_stream_cleanup (server_stream);
 
    EXIT;
 }
 
 
-static void
-_mongoc_client_monitor_op_killcursors (mongoc_cluster_t *cluster,
-                                       mongoc_server_stream_t *server_stream,
-                                       int64_t cursor_id,
-                                       int64_t operation_id,
-                                       const char *db,
-                                       const char *collection)
-{
-   bson_t doc;
-   mongoc_apm_command_started_t event;
-
-   ENTRY;
-
-   mongoc_client_t *client = cluster->client;
-   const mongoc_log_and_monitor_instance_t *log_and_monitor = &client->topology->log_and_monitor;
-
-   if (!log_and_monitor->apm_callbacks.started) {
-      return;
-   }
-
-   bson_init (&doc);
-   _mongoc_client_prepare_killcursors_command (cursor_id, collection, &doc);
-   mongoc_apm_command_started_init (&event,
-                                    &doc,
-                                    db,
-                                    "killCursors",
-                                    cluster->request_id,
-                                    operation_id,
-                                    &server_stream->sd->host,
-                                    server_stream->sd->id,
-                                    &server_stream->sd->service_id,
-                                    server_stream->sd->server_connection_id,
-                                    NULL,
-                                    log_and_monitor->apm_context);
-
-   log_and_monitor->apm_callbacks.started (&event);
-   mongoc_apm_command_started_cleanup (&event);
-   bson_destroy (&doc);
-
-   EXIT;
-}
-
-
-static void
-_mongoc_client_monitor_op_killcursors_succeeded (mongoc_cluster_t *cluster,
-                                                 int64_t duration,
-                                                 mongoc_server_stream_t *server_stream,
-                                                 int64_t cursor_id,
-                                                 int64_t operation_id,
-                                                 const char *db)
-{
-   bson_t doc;
-   bson_array_builder_t *cursors_unknown;
-   mongoc_apm_command_succeeded_t event;
-
-   ENTRY;
-
-   mongoc_client_t *client = cluster->client;
-   const mongoc_log_and_monitor_instance_t *log_and_monitor = &client->topology->log_and_monitor;
-
-   if (!log_and_monitor->apm_callbacks.succeeded) {
-      EXIT;
-   }
-
-   /* fake server reply to killCursors command: {ok: 1, cursorsUnknown: [42]} */
-   bson_init (&doc);
-   bson_append_int32 (&doc, "ok", 2, 1);
-   bson_append_array_builder_begin (&doc, "cursorsUnknown", 14, &cursors_unknown);
-   bson_array_builder_append_int64 (cursors_unknown, cursor_id);
-   bson_append_array_builder_end (&doc, cursors_unknown);
-
-   mongoc_apm_command_succeeded_init (&event,
-                                      duration,
-                                      &doc,
-                                      "killCursors",
-                                      db,
-                                      cluster->request_id,
-                                      operation_id,
-                                      &server_stream->sd->host,
-                                      server_stream->sd->id,
-                                      &server_stream->sd->service_id,
-                                      server_stream->sd->server_connection_id,
-                                      false,
-                                      log_and_monitor->apm_context);
-
-   log_and_monitor->apm_callbacks.succeeded (&event);
-
-   mongoc_apm_command_succeeded_cleanup (&event);
-   bson_destroy (&doc);
-}
-
-
-static void
-_mongoc_client_monitor_op_killcursors_failed (mongoc_cluster_t *cluster,
-                                              int64_t duration,
-                                              mongoc_server_stream_t *server_stream,
-                                              const bson_error_t *error,
-                                              int64_t operation_id,
-                                              const char *db)
-{
-   bson_t doc;
-   mongoc_apm_command_failed_t event;
-
-   ENTRY;
-
-   mongoc_client_t *client = cluster->client;
-   const mongoc_log_and_monitor_instance_t *log_and_monitor = &client->topology->log_and_monitor;
-
-   if (!log_and_monitor->apm_callbacks.failed) {
-      EXIT;
-   }
-
-   /* fake server reply to killCursors command: {ok: 0} */
-   bson_init (&doc);
-   bson_append_int32 (&doc, "ok", 2, 0);
-
-   mongoc_apm_command_failed_init (&event,
-                                   duration,
-                                   "killCursors",
-                                   db,
-                                   error,
-                                   &doc,
-                                   cluster->request_id,
-                                   operation_id,
-                                   &server_stream->sd->host,
-                                   server_stream->sd->id,
-                                   &server_stream->sd->service_id,
-                                   server_stream->sd->server_connection_id,
-                                   false,
-                                   log_and_monitor->apm_context);
-
-   log_and_monitor->apm_callbacks.failed (&event);
-
-   mongoc_apm_command_failed_cleanup (&event);
-   bson_destroy (&doc);
-}
-
-
-static void
-_mongoc_client_op_killcursors (mongoc_cluster_t *cluster,
-                               mongoc_server_stream_t *server_stream,
-                               int64_t cursor_id,
-                               int64_t operation_id,
-                               const char *db,
-                               const char *collection)
-{
-   BSON_ASSERT_PARAM (cluster);
-   BSON_ASSERT_PARAM (server_stream);
-   BSON_OPTIONAL_PARAM (db);
-   BSON_OPTIONAL_PARAM (collection);
-
-   const bool has_ns = db && collection;
-   const int64_t started = bson_get_monotonic_time ();
-
-   mcd_rpc_message *const rpc = mcd_rpc_message_new ();
-
-   {
-      int32_t message_length = 0;
-
-      message_length += mcd_rpc_header_set_message_length (rpc, 0);
-      message_length += mcd_rpc_header_set_request_id (rpc, ++cluster->request_id);
-      message_length += mcd_rpc_header_set_response_to (rpc, 0);
-      message_length += mcd_rpc_header_set_op_code (rpc, MONGOC_OP_CODE_KILL_CURSORS);
-
-      message_length += sizeof (int32_t); // ZERO
-      message_length += mcd_rpc_op_kill_cursors_set_cursor_ids (rpc, &cursor_id, 1);
-
-      mcd_rpc_message_set_length (rpc, message_length);
-   }
-
-   if (has_ns) {
-      _mongoc_client_monitor_op_killcursors (cluster, server_stream, cursor_id, operation_id, db, collection);
-   }
-
-   bson_error_t error;
-   const bool res = mongoc_cluster_legacy_rpc_sendv_to_server (cluster, rpc, server_stream, &error);
-
-   if (has_ns) {
-      if (res) {
-         _mongoc_client_monitor_op_killcursors_succeeded (
-            cluster, bson_get_monotonic_time () - started, server_stream, cursor_id, operation_id, db);
-      } else {
-         _mongoc_client_monitor_op_killcursors_failed (
-            cluster, bson_get_monotonic_time () - started, server_stream, &error, operation_id, db);
-      }
-   }
-
-   mcd_rpc_message_destroy (rpc);
-}
-
-
 static void
 _mongoc_client_killcursors_command (mongoc_cluster_t *cluster,
                                     mongoc_server_stream_t *server_stream,
@@ -2343,75 +2142,6 @@ _mongoc_client_killcursors_command (mongoc_cluster_t *cluster,
 }
 
 
-/*
- *--------------------------------------------------------------------------
- *
- * mongoc_client_kill_cursor --
- *
- *       Destroy a cursor on the server.
- *
- *       NOTE: this is only reliable when connected to a single mongod or
- *       mongos. If connected to a replica set, the driver attempts to
- *       kill the cursor on the primary. If connected to multiple mongoses
- *       the kill-cursors message is sent to a *random* mongos.
- *
- *       If no primary, mongos, or standalone server is known, return
- *       without attempting to reconnect.
- *
- * Returns:
- *       None.
- *
- * Side effects:
- *       None.
- *
- *--------------------------------------------------------------------------
- */
-
-void
-mongoc_client_kill_cursor (mongoc_client_t *client, int64_t cursor_id)
-{
-   BSON_ASSERT_PARAM (client);
-
-   mongoc_topology_t *const topology = BSON_ASSERT_PTR_INLINE (client)->topology;
-   mongoc_server_description_t const *selected_server;
-   mongoc_read_prefs_t *read_prefs;
-   bson_error_t error;
-   uint32_t server_id = 0;
-   mc_shared_tpld td = mc_tpld_take_ref (topology);
-
-   read_prefs = mongoc_read_prefs_new (MONGOC_READ_PRIMARY);
-
-   if (!mongoc_topology_compatible (td.ptr, NULL, &error)) {
-      MONGOC_ERROR ("Could not kill cursor: %s", error.message);
-      mc_tpld_drop_ref (&td);
-      mongoc_read_prefs_destroy (read_prefs);
-      return;
-   }
-
-   /* see if there's a known writable server - do no I/O or retries */
-   selected_server = mongoc_topology_description_select (td.ptr,
-                                                         MONGOC_SS_WRITE,
-                                                         read_prefs,
-                                                         NULL /* chosen read mode */,
-                                                         NULL /* deprioritized servers */,
-                                                         topology->local_threshold_msec);
-
-   if (selected_server) {
-      server_id = selected_server->id;
-   }
-
-   if (server_id) {
-      _mongoc_client_kill_cursor (
-         client, server_id, cursor_id, 0 /* operation_id */, NULL /* db */, NULL /* collection */, NULL /* session */);
-   } else {
-      MONGOC_INFO ("No server available for mongoc_client_kill_cursor");
-   }
-
-   mongoc_read_prefs_destroy (read_prefs);
-   mc_tpld_drop_ref (&td);
-}
-
-
 char **
 mongoc_client_get_database_names (mongoc_client_t *client, bson_error_t *error)
 {

src/libmongoc/src/mongoc/mongoc-client.h

@@ -120,11 +120,6 @@ mongoc_client_get_uri (const mongoc_client_t *client);
 MONGOC_EXPORT (void)
 mongoc_client_set_stream_initiator (mongoc_client_t *client, mongoc_stream_initiator_t initiator, void *user_data);
 
-
-BSON_DEPRECATED ("mongoc_client_kill_cursor is deprecated")
-MONGOC_EXPORT (void) mongoc_client_kill_cursor (mongoc_client_t *client, int64_t cursor_id);
-
-
 MONGOC_EXPORT (bool)
 mongoc_client_command_simple (mongoc_client_t *client,
                               const char *db_name,