Add reconnect interop test client and server

build.json

@@ -566,6 +566,23 @@
       "secure": "no",
       "vs_project_guid": "{46CEDFFF-9692-456A-AA24-38B5D6BCF4C5}"
     },
+    {
+      "name": "reconnect_server",
+      "build": "private",
+      "language": "c",
+      "headers": [
+        "test/core/util/reconnect_server.h"
+      ],
+      "src": [
+        "test/core/util/reconnect_server.c"
+      ],
+      "deps": [
+        "grpc_test_util",
+        "grpc",
+        "gpr_test_util",
+        "gpr"
+      ]
+    },
     {
       "name": "grpc++",
       "build": "all",
@@ -2389,6 +2406,49 @@
         "grpc++_test_config"
       ]
     },
+    {
+      "name": "reconnect_interop_client",
+      "build": "test",
+      "run": false,
+      "language": "c++",
+      "src": [
+        "test/proto/empty.proto",
+        "test/proto/messages.proto",
+        "test/proto/test.proto",
+        "test/cpp/interop/reconnect_interop_client.cc"
+      ],
+      "deps": [
+        "grpc++_test_util",
+        "grpc_test_util",
+        "grpc++",
+        "grpc",
+        "gpr_test_util",
+        "gpr",
+        "grpc++_test_config"
+      ]
+    },
+    {
+      "name": "reconnect_interop_server",
+      "build": "test",
+      "run": false,
+      "language": "c++",
+      "src": [
+        "test/proto/empty.proto",
+        "test/proto/messages.proto",
+        "test/proto/test.proto",
+        "test/cpp/interop/reconnect_interop_server.cc"
+      ],
+      "deps": [
+        "reconnect_server",
+        "grpc++_test_util",
+        "grpc_test_util",
+        "grpc++",
+        "grpc",
+        "gpr_test_util",
+        "gpr",
+        "grpc++_test_config"
+      ]
+    },
     {
       "name": "secure_auth_context_test",
       "build": "test",

src/core/client_config/subchannel.c

@@ -322,8 +322,8 @@ static void continue_connect(grpc_subchannel *c) {
 static void start_connect(grpc_subchannel *c) {
   c->backoff_delta = gpr_time_from_seconds(
       GRPC_SUBCHANNEL_INITIAL_CONNECT_BACKOFF_SECONDS, GPR_TIMESPAN);
-  c->next_attempt = gpr_time_add(
-      gpr_now(GPR_CLOCK_MONOTONIC), c->backoff_delta);
+  c->next_attempt =
+      gpr_time_add(gpr_now(GPR_CLOCK_MONOTONIC), c->backoff_delta);
   continue_connect(c);
 }
 

test/core/util/reconnect_server.c

@@ -0,0 +1,140 @@
+/*
+ *
+ * Copyright 2015, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/util/reconnect_server.h"
+
+#include <grpc/grpc.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/host_port.h>
+#include <grpc/support/log.h>
+#include <grpc/support/sync.h>
+#include <grpc/support/time.h>
+#include "src/core/iomgr/endpoint.h"
+#include "src/core/iomgr/tcp_server.h"
+#include "test/core/util/port.h"
+#include <arpa/inet.h>
+
+static void pretty_print_backoffs(reconnect_server *server) {
+  gpr_timespec diff;
+  int i = 1;
+  double expected_backoff = 1000.0, backoff;
+  timestamp_list *head = server->head;
+  gpr_log(GPR_INFO, "reconnect server: new connection");
+  for (head = server->head; head && head->next; head = head->next, i++) {
+    diff = gpr_time_sub(head->next->timestamp, head->timestamp);
+    backoff = gpr_time_to_millis(diff);
+    gpr_log(GPR_INFO,
+            "retry %2d:backoff %6.2fs,expected backoff %6.2fs, jitter %4.2f%%",
+            i, backoff / 1000.0, expected_backoff / 1000.0,
+            (backoff - expected_backoff) * 100.0 / expected_backoff);
+    expected_backoff *= 1.6;
+    if (expected_backoff > 120 * 1000) {
+      expected_backoff = 120 * 1000;
+    }
+  }
+}
+
+static void on_connect(void *arg, grpc_endpoint *tcp) {
+  reconnect_server *server = (reconnect_server *)arg;
+  gpr_timespec now = gpr_now(GPR_CLOCK_REALTIME);
+  timestamp_list *new_tail;
+  grpc_endpoint_shutdown(tcp);
+  grpc_endpoint_destroy(tcp);
+  new_tail = gpr_malloc(sizeof(timestamp_list));
+  new_tail->timestamp = now;
+  new_tail->next = NULL;
+  if (server->tail == NULL) {
+    server->head = new_tail;
+    server->tail = new_tail;
+  } else {
+    server->tail->next = new_tail;
+    server->tail = new_tail;
+  }
+  pretty_print_backoffs(server);
+}
+
+void reconnect_server_init(reconnect_server *server) {
+  grpc_init();
+  server->tcp_server = NULL;
+  grpc_pollset_init(&server->pollset);
+  server->pollsets[0] = &server->pollset;
+  server->head = NULL;
+  server->tail = NULL;
+}
+
+void reconnect_server_start(reconnect_server *server, int port) {
+  struct sockaddr_in addr;
+  int port_added;
+
+  addr.sin_family = AF_INET;
+  addr.sin_port = htons(port);
+  inet_pton(AF_INET, "0.0.0.0", &addr.sin_addr);
+
+  server->tcp_server = grpc_tcp_server_create();
+  port_added =
+      grpc_tcp_server_add_port(server->tcp_server, &addr, sizeof(addr));
+  GPR_ASSERT(port_added == port);
+
+  grpc_tcp_server_start(server->tcp_server, server->pollsets, 1, on_connect,
+                        server);
+  gpr_log(GPR_INFO, "reconnect tcp server listening on 0.0.0.0:%d", port);
+}
+
+void reconnect_server_poll(reconnect_server *server, int seconds) {
+  gpr_timespec deadline =
+      gpr_time_add(gpr_now(GPR_CLOCK_MONOTONIC),
+                   gpr_time_from_seconds(seconds, GPR_TIMESPAN));
+  gpr_mu_lock(GRPC_POLLSET_MU(&server->pollset));
+  grpc_pollset_work(&server->pollset, deadline);
+  gpr_mu_unlock(GRPC_POLLSET_MU(&server->pollset));
+}
+
+void reconnect_server_clear_timestamps(reconnect_server *server) {
+  timestamp_list *new_head = server->head;
+  while (server->head) {
+    new_head = server->head->next;
+    gpr_free(server->head);
+    server->head = new_head;
+  }
+  server->tail = NULL;
+}
+
+static void do_nothing(void *ignored) {}
+
+void reconnect_server_destroy(reconnect_server *server) {
+  grpc_tcp_server_destroy(server->tcp_server, do_nothing, NULL);
+  reconnect_server_clear_timestamps(server);
+  grpc_pollset_shutdown(&server->pollset, do_nothing, NULL);
+  grpc_pollset_destroy(&server->pollset);
+  grpc_shutdown();
+}

test/core/util/reconnect_server.h

@@ -0,0 +1,68 @@
+/*
+ *
+ * Copyright 2015, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef GRPC_TEST_CORE_UTIL_RECONNECT_SERVER_H
+#define GRPC_TEST_CORE_UTIL_RECONNECT_SERVER_H
+
+#include <grpc/support/sync.h>
+#include <grpc/support/time.h>
+#include "src/core/iomgr/tcp_server.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct timestamp_list {
+  gpr_timespec timestamp;
+  struct timestamp_list *next;
+} timestamp_list;
+
+typedef struct reconnect_server {
+  grpc_tcp_server *tcp_server;
+  grpc_pollset pollset;
+  grpc_pollset *pollsets[1];
+  timestamp_list *head;
+  timestamp_list *tail;
+} reconnect_server;
+
+void reconnect_server_init(reconnect_server *server);
+void reconnect_server_start(reconnect_server *server, int port);
+void reconnect_server_poll(reconnect_server *server, int seconds);
+void reconnect_server_destroy(reconnect_server *server);
+void reconnect_server_clear_timestamps(reconnect_server *server);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GRPC_TEST_CORE_UTIL_RECONNECT_SERVER_H */

test/cpp/interop/reconnect_interop_client.cc

@@ -0,0 +1,103 @@
+/*
+ *
+ * Copyright 2015, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <memory>
+#include <sstream>
+
+#include <grpc/grpc.h>
+#include <grpc/support/log.h>
+#include <gflags/gflags.h>
+#include <grpc++/channel_interface.h>
+#include <grpc++/client_context.h>
+#include <grpc++/status.h>
+#include "test/cpp/util/create_test_channel.h"
+#include "test/cpp/util/test_config.h"
+#include "test/proto/test.grpc.pb.h"
+#include "test/proto/empty.grpc.pb.h"
+#include "test/proto/messages.grpc.pb.h"
+
+DEFINE_int32(server_control_port, 0, "Server port for control rpcs.");
+DEFINE_int32(server_retry_port, 0, "Server port for testing reconnection.");
+DEFINE_string(server_host, "127.0.0.1", "Server host to connect to");
+
+using grpc::ChannelInterface;
+using grpc::ClientContext;
+using grpc::CreateTestChannel;
+using grpc::Status;
+using grpc::testing::Empty;
+using grpc::testing::ReconnectInfo;
+using grpc::testing::ReconnectService;
+
+int main(int argc, char** argv) {
+  grpc::testing::InitTest(&argc, &argv, true);
+  GPR_ASSERT(FLAGS_server_control_port);
+  GPR_ASSERT(FLAGS_server_retry_port);
+
+  std::ostringstream server_address;
+  server_address << FLAGS_server_host << ':' << FLAGS_server_control_port;
+  std::unique_ptr<ReconnectService::Stub> control_stub(
+      ReconnectService::NewStub(
+          CreateTestChannel(server_address.str(), false)));
+  ClientContext start_context;
+  Empty empty_request;
+  Empty empty_response;
+  Status start_status =
+      control_stub->Start(&start_context, empty_request, &empty_response);
+  GPR_ASSERT(start_status.ok());
+
+  gpr_log(GPR_INFO, "Starting connections with retries.");
+  server_address.str("");
+  server_address << FLAGS_server_host << ':' << FLAGS_server_retry_port;
+  std::shared_ptr<ChannelInterface> retry_channel =
+      CreateTestChannel(server_address.str(), true);
+  // About 13 retries.
+  const int kDeadlineSeconds = 540;
+  // Use any rpc to test retry.
+  std::unique_ptr<ReconnectService::Stub> retry_stub(
+      ReconnectService::NewStub(retry_channel));
+  ClientContext retry_context;
+  retry_context.set_deadline(std::chrono::system_clock::now() +
+                             std::chrono::seconds(kDeadlineSeconds));
+  Status retry_status =
+      retry_stub->Start(&retry_context, empty_request, &empty_response);
+  GPR_ASSERT(retry_status.error_code() == grpc::StatusCode::DEADLINE_EXCEEDED);
+  gpr_log(GPR_INFO, "Done retrying, getting final data from server");
+
+  ClientContext stop_context;
+  ReconnectInfo response;
+  Status stop_status =
+      control_stub->Stop(&stop_context, empty_request, &response);
+  GPR_ASSERT(stop_status.ok());
+  GPR_ASSERT(response.passed() == true);
+  return 0;
+}

test/cpp/interop/reconnect_interop_server.cc

@@ -0,0 +1,165 @@
+/*
+ *
+ * Copyright 2015, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <memory>
+#include <sstream>
+#include <thread>
+
+#include <signal.h>
+#include <unistd.h>
+
+#include <gflags/gflags.h>
+#include <grpc/grpc.h>
+#include <grpc/support/log.h>
+#include <grpc++/config.h>
+#include <grpc++/server.h>
+#include <grpc++/server_builder.h>
+#include <grpc++/server_context.h>
+#include <grpc++/server_credentials.h>
+#include <grpc++/status.h>
+#include <grpc++/stream.h>
+#include "test/core/util/reconnect_server.h"
+#include "test/cpp/util/test_config.h"
+#include "test/proto/test.grpc.pb.h"
+#include "test/proto/empty.grpc.pb.h"
+#include "test/proto/messages.grpc.pb.h"
+
+DEFINE_int32(control_port, 0, "Server port for controlling the server.");
+DEFINE_int32(retry_port, 0,
+             "Server port for raw tcp connections. All incoming "
+             "connections will be closed immediately.");
+
+using grpc::Server;
+using grpc::ServerBuilder;
+using grpc::ServerContext;
+using grpc::ServerCredentials;
+using grpc::ServerReader;
+using grpc::ServerReaderWriter;
+using grpc::ServerWriter;
+using grpc::SslServerCredentialsOptions;
+using grpc::Status;
+using grpc::testing::Empty;
+using grpc::testing::ReconnectService;
+using grpc::testing::ReconnectInfo;
+
+static bool got_sigint = false;
+
+class ReconnectServiceImpl : public ReconnectService::Service {
+ public:
+  explicit ReconnectServiceImpl(int retry_port) : retry_port_(retry_port) {
+    reconnect_server_init(&tcp_server_);
+  }
+
+  ~ReconnectServiceImpl() {
+    if (tcp_server_.tcp_server) {
+      reconnect_server_destroy(&tcp_server_);
+    }
+  }
+
+  void Poll(int seconds) { reconnect_server_poll(&tcp_server_, seconds); }
+
+  Status Start(ServerContext* context, const Empty* request, Empty* response) {
+    if (!tcp_server_.tcp_server) {
+      reconnect_server_start(&tcp_server_, retry_port_);
+    } else {
+      reconnect_server_clear_timestamps(&tcp_server_);
+    }
+    return Status::OK;
+  }
+
+  Status Stop(ServerContext* context, const Empty* request,
+              ReconnectInfo* response) {
+    // extract timestamps and set response
+    Verify(response);
+    reconnect_server_clear_timestamps(&tcp_server_);
+    return Status::OK;
+  }
+
+  void Verify(ReconnectInfo* response) {
+    double expected_backoff = 1000.0;
+    const double kTransmissionDelay = 100.0;
+    const double kBackoffMultiplier = 1.6;
+    const double kJitterFactor = 0.2;
+    const int kMaxBackoffMs = 120 * 1000;
+    bool passed = true;
+    for (timestamp_list* cur = tcp_server_.head; cur && cur->next;
+         cur = cur->next) {
+      double backoff = gpr_time_to_millis(
+          gpr_time_sub(cur->next->timestamp, cur->timestamp));
+      double min_backoff = expected_backoff * (1 - kJitterFactor);
+      double max_backoff = expected_backoff * (1 + kJitterFactor);
+      if (backoff < min_backoff - kTransmissionDelay ||
+          backoff > max_backoff + kTransmissionDelay) {
+        passed = false;
+      }
+      response->add_backoff_ms(static_cast<gpr_int32>(backoff));
+      expected_backoff *= kBackoffMultiplier;
+      expected_backoff =
+          expected_backoff > kMaxBackoffMs ? kMaxBackoffMs : expected_backoff;
+    }
+    response->set_passed(passed);
+  }
+
+ private:
+  int retry_port_;
+  reconnect_server tcp_server_;
+};
+
+void RunServer() {
+  std::ostringstream server_address;
+  server_address << "0.0.0.0:" << FLAGS_control_port;
+  ReconnectServiceImpl service(FLAGS_retry_port);
+
+  ServerBuilder builder;
+  builder.RegisterService(&service);
+  builder.AddListeningPort(server_address.str(),
+                           grpc::InsecureServerCredentials());
+  std::unique_ptr<Server> server(builder.BuildAndStart());
+  gpr_log(GPR_INFO, "Server listening on %s", server_address.str().c_str());
+  while (!got_sigint) {
+    service.Poll(5);
+  }
+}
+
+static void sigint_handler(int x) { got_sigint = true; }
+
+int main(int argc, char** argv) {
+  grpc::testing::InitTest(&argc, &argv, true);
+  signal(SIGINT, sigint_handler);
+
+  GPR_ASSERT(FLAGS_control_port != 0);
+  GPR_ASSERT(FLAGS_retry_port != 0);
+  RunServer();
+
+  return 0;
+}

test/proto/messages.proto

@@ -157,3 +157,11 @@ message StreamingOutputCallResponse {
   // Payload to increase response size.
   optional Payload payload = 1;
 }
+
+// For reconnect interop test only.
+// Server tells client whether its reconnects are following the spec and the
+// reconnect backoffs it saw.
+message ReconnectInfo {
+  optional bool passed = 1;
+  repeated int32 backoff_ms = 2;
+}

test/proto/test.proto

@@ -79,3 +79,9 @@ service UnimplementedService {
   // A call that no server should implement
   rpc UnimplementedCall(grpc.testing.Empty) returns(grpc.testing.Empty);  
 }
+
+// A service used to control reconnect server.
+service ReconnectService {
+  rpc Start(grpc.testing.Empty) returns (grpc.testing.Empty);
+  rpc Stop(grpc.testing.Empty) returns (grpc.testing.ReconnectInfo);
+}

tools/run_tests/sources_and_headers.json

@@ -1509,6 +1509,55 @@
       "test/cpp/qps/worker.cc"
     ]
   }, 
+  {
+    "deps": [
+      "gpr", 
+      "gpr_test_util", 
+      "grpc", 
+      "grpc++", 
+      "grpc++_test_config", 
+      "grpc++_test_util", 
+      "grpc_test_util"
+    ], 
+    "headers": [
+      "test/proto/empty.grpc.pb.h", 
+      "test/proto/empty.pb.h", 
+      "test/proto/messages.grpc.pb.h", 
+      "test/proto/messages.pb.h", 
+      "test/proto/test.grpc.pb.h", 
+      "test/proto/test.pb.h"
+    ], 
+    "language": "c++", 
+    "name": "reconnect_interop_client", 
+    "src": [
+      "test/cpp/interop/reconnect_interop_client.cc"
+    ]
+  }, 
+  {
+    "deps": [
+      "gpr", 
+      "gpr_test_util", 
+      "grpc", 
+      "grpc++", 
+      "grpc++_test_config", 
+      "grpc++_test_util", 
+      "grpc_test_util", 
+      "reconnect_server"
+    ], 
+    "headers": [
+      "test/proto/empty.grpc.pb.h", 
+      "test/proto/empty.pb.h", 
+      "test/proto/messages.grpc.pb.h", 
+      "test/proto/messages.pb.h", 
+      "test/proto/test.grpc.pb.h", 
+      "test/proto/test.pb.h"
+    ], 
+    "language": "c++", 
+    "name": "reconnect_interop_server", 
+    "src": [
+      "test/cpp/interop/reconnect_interop_server.cc"
+    ]
+  }, 
   {
     "deps": [
       "gpr", 
@@ -11551,6 +11600,23 @@
       "src/core/transport/transport_op_string.c"
     ]
   }, 
+  {
+    "deps": [
+      "gpr", 
+      "gpr_test_util", 
+      "grpc", 
+      "grpc_test_util"
+    ], 
+    "headers": [
+      "test/core/util/reconnect_server.h"
+    ], 
+    "language": "c", 
+    "name": "reconnect_server", 
+    "src": [
+      "test/core/util/reconnect_server.c", 
+      "test/core/util/reconnect_server.h"
+    ]
+  }, 
   {
     "deps": [
       "gpr",