Bug #17309863 AUTO RECONNECT DOES NOT WORK WITH 5.6 LIBMYSQLCLIENT

vsmurthys · vsmurthys · commit a098f4665ea2 · 2014-05-19T22:01:55.000+05:30
Problem Statement: Automatic reconnection does not work for MySQL client
programs linked with 5.6 libmysqlclient, even if MYSQL_OPT_RECONNECT is enabled.

Analysis:
When we have two connections (say con_1 and con_2) in which 'con_1' has
auto-reconnect enabled. In such case if 'con_2' sends 'KILL &lt;con_1 id&gt;'
(killing 'con_1'), then the server closes the socket for 'con_1'.
After that when we send any query to 'con_1' it is failing with "Lost
connection to MySQL server during query" error, even though auto-reconnect
is enabled for 'con_1'.
This is because send() which sends query might still succeed on client
even though connection has been already closed on server. Since send()
returns success at client side, client tries to recv() the data. Now
client receives '0' means that the peer has closed the connection.
Hence the query fails with the error mentioned above.

Problem didn't exist in 5.5 and earlier versions because in them we tried
to read-up all data remaining from previous command before sending new one
to the server. As result we detected that connection was closed before
query was sent and re-established connection.

Fix:
Check if socket is alive using vio_is_connected() call in case if
auto-reconnect is enabled before sending query to server. If socket
was disconnected by server set net-&gt;error to 2 so the socket on the
client will be closed as well and reconnect will be initiated before
sending the query. Reconnect doesn't make sense in case of COM_QUIT
so skip the connection check for this command.

Note: This fix doesn't solve the problem fully as bug still can
occur if connection is killed exactly after this check and before
query is sent. But this is acceptable since similar problem
exists in 5.5.

Also note that this patch might cause slight performance degradation,
but it affects only auto-reconnect mode and therefore acceptable.
diff --git a/sql-common/client.c b/sql-common/client.c
@@ -724,6 +724,20 @@ cli_advanced_command(MYSQL *mysql, enum enum_server_command command,
   */
   net_clear(&mysql->net, (command != COM_QUIT));
 
+#if !defined(EMBEDDED_LIBRARY)
+  /*
+    If auto-reconnect mode is enabled check if connection is still alive before
+    sending new command. Otherwise, send() might not notice that connection was
+    closed by the server (for example, due to KILL statement), and the fact that
+    connection is gone will be noticed only on attempt to read command's result,
+    when it is too late to reconnect. Note that such scenario can still occur if
+    connection gets killed after this check but before command is sent to
+    server. But this should be rare.
+  */
+  if ((command != COM_QUIT) && mysql->reconnect && !vio_is_connected(net->vio))
+    net->error= 2;
+#endif
+
   if (net_write_command(net,(uchar) command, header, header_length,
 			arg, arg_length))
   {
diff --git a/tests/mysql_client_test.c b/tests/mysql_client_test.c
@@ -19301,6 +19301,57 @@ static void test_wl6587()
   myquery(rc);
 }
 
+#ifndef EMBEDDED_LIBRARY
+/*
+  Bug #17309863 AUTO RECONNECT DOES NOT WORK WITH 5.6 LIBMYSQLCLIENT
+*/
+static void test_bug17309863()
+{
+  MYSQL *lmysql;
+  unsigned long thread_id;
+  char query[MAX_TEST_QUERY_LENGTH];
+  int rc;
+
+  myheader("test_bug17309863");
+
+  if (!opt_silent)
+    fprintf(stdout, "\n Establishing a test connection ...");
+  if (!(lmysql= mysql_client_init(NULL)))
+  {
+    myerror("mysql_client_init() failed");
+    exit(1);
+  }
+  lmysql->reconnect= 1;
+  if (!(mysql_real_connect(lmysql, opt_host, opt_user,
+                           opt_password, current_db, opt_port,
+                           opt_unix_socket, 0)))
+  {
+    myerror("connection failed");
+    exit(1);
+  }
+  if (!opt_silent)
+    fprintf(stdout, "OK");
+
+  thread_id= mysql_thread_id(lmysql);
+  sprintf(query, "KILL %lu", thread_id);
+
+  /*
+    Running the "KILL <thread_id>" query in a separate connection.
+  */
+  if (thread_query(query))
+    exit(1);
+
+  /*
+    The above KILL statement should have closed our connection. But reconnect
+    flag allows to detect this before sending query and re-establish it without
+    returning an error.
+  */
+  rc= mysql_query(lmysql, "SELECT 'bug17309863'");
+  myquery(rc);
+
+  mysql_close(lmysql);
+}
+#endif
 
 static struct my_tests_st my_tests[]= {
   { "disable_query_logs", disable_query_logs },
@@ -19573,6 +19624,9 @@ static struct my_tests_st my_tests[]= {
   { "test_wl5968", test_wl5968 },
   { "test_wl5924", test_wl5924 },
   { "test_wl6587", test_wl6587 },
+#ifndef EMBEDDED_LIBRARY
+  { "test_bug17309863", test_bug17309863},
+#endif
   { 0, 0 }
 };
 
