ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 1 | /* |
| 2 | * |
Craig Tiller | 0605995 | 2015-02-18 08:34:56 -0800 | [diff] [blame] | 3 | * Copyright 2015, Google Inc. |
ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 4 | * All rights reserved. |
| 5 | * |
| 6 | * Redistribution and use in source and binary forms, with or without |
| 7 | * modification, are permitted provided that the following conditions are |
| 8 | * met: |
| 9 | * |
| 10 | * * Redistributions of source code must retain the above copyright |
| 11 | * notice, this list of conditions and the following disclaimer. |
| 12 | * * Redistributions in binary form must reproduce the above |
| 13 | * copyright notice, this list of conditions and the following disclaimer |
| 14 | * in the documentation and/or other materials provided with the |
| 15 | * distribution. |
| 16 | * * Neither the name of Google Inc. nor the names of its |
| 17 | * contributors may be used to endorse or promote products derived from |
| 18 | * this software without specific prior written permission. |
| 19 | * |
| 20 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| 21 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| 22 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| 23 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| 24 | * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| 25 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| 26 | * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| 27 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| 28 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| 29 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| 30 | * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 31 | * |
| 32 | */ |
| 33 | |
| 34 | #include "src/core/iomgr/tcp_client.h" |
| 35 | |
| 36 | #include <errno.h> |
| 37 | #include <netinet/in.h> |
| 38 | #include <string.h> |
| 39 | #include <sys/socket.h> |
| 40 | #include <unistd.h> |
| 41 | |
Craig Tiller | be95249 | 2015-08-25 16:59:00 -0700 | [diff] [blame] | 42 | #include <grpc/grpc.h> |
ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 43 | #include <grpc/support/log.h> |
| 44 | #include <grpc/support/time.h> |
Craig Tiller | be95249 | 2015-08-25 16:59:00 -0700 | [diff] [blame] | 45 | |
| 46 | #include "src/core/iomgr/iomgr.h" |
| 47 | #include "src/core/iomgr/socket_utils_posix.h" |
Craig Tiller | 8ad8a41 | 2015-02-25 08:36:40 -0800 | [diff] [blame] | 48 | #include "test/core/util/test_config.h" |
ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 49 | |
Craig Tiller | b1fa1d5 | 2015-05-11 10:27:53 -0700 | [diff] [blame] | 50 | static grpc_pollset_set g_pollset_set; |
| 51 | static grpc_pollset g_pollset; |
Craig Tiller | cb63a9b | 2015-05-13 09:52:36 -0700 | [diff] [blame] | 52 | static int g_connections_complete = 0; |
Craig Tiller | dfff1b8 | 2015-09-21 14:39:57 -0700 | [diff] [blame] | 53 | static grpc_endpoint *g_connecting = NULL; |
Craig Tiller | b1fa1d5 | 2015-05-11 10:27:53 -0700 | [diff] [blame] | 54 | |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 55 | static gpr_timespec |
| 56 | test_deadline (void) |
| 57 | { |
| 58 | return GRPC_TIMEOUT_SECONDS_TO_DEADLINE (10); |
ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 59 | } |
| 60 | |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 61 | static void |
| 62 | finish_connection () |
| 63 | { |
| 64 | gpr_mu_lock (GRPC_POLLSET_MU (&g_pollset)); |
Craig Tiller | cb63a9b | 2015-05-13 09:52:36 -0700 | [diff] [blame] | 65 | g_connections_complete++; |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 66 | grpc_pollset_kick (&g_pollset, NULL); |
| 67 | gpr_mu_unlock (GRPC_POLLSET_MU (&g_pollset)); |
Craig Tiller | cb63a9b | 2015-05-13 09:52:36 -0700 | [diff] [blame] | 68 | } |
| 69 | |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 70 | static void |
Craig Tiller | 1be70cc | 2015-09-22 10:45:28 -0700 | [diff] [blame^] | 71 | must_succeed (grpc_exec_ctx * exec_ctx, void *arg, int success) |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 72 | { |
| 73 | GPR_ASSERT (g_connecting != NULL); |
| 74 | GPR_ASSERT (success); |
| 75 | grpc_endpoint_shutdown (g_connecting, closure_list); |
| 76 | grpc_endpoint_destroy (g_connecting, closure_list); |
Craig Tiller | dfff1b8 | 2015-09-21 14:39:57 -0700 | [diff] [blame] | 77 | g_connecting = NULL; |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 78 | finish_connection (); |
ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 79 | } |
| 80 | |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 81 | static void |
Craig Tiller | 1be70cc | 2015-09-22 10:45:28 -0700 | [diff] [blame^] | 82 | must_fail (grpc_exec_ctx * exec_ctx, void *arg, int success) |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 83 | { |
| 84 | GPR_ASSERT (g_connecting == NULL); |
| 85 | GPR_ASSERT (!success); |
| 86 | finish_connection (); |
ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 87 | } |
| 88 | |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 89 | void |
| 90 | test_succeeds (void) |
| 91 | { |
ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 92 | struct sockaddr_in addr; |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 93 | socklen_t addr_len = sizeof (addr); |
ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 94 | int svr_fd; |
| 95 | int r; |
Craig Tiller | cb63a9b | 2015-05-13 09:52:36 -0700 | [diff] [blame] | 96 | int connections_complete_before; |
Craig Tiller | dfff1b8 | 2015-09-21 14:39:57 -0700 | [diff] [blame] | 97 | grpc_closure done; |
Craig Tiller | d9ccbbf | 2015-09-22 09:30:00 -0700 | [diff] [blame] | 98 | grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT; |
ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 99 | |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 100 | gpr_log (GPR_DEBUG, "test_succeeds"); |
Craig Tiller | e959335 | 2015-07-15 07:35:09 -0700 | [diff] [blame] | 101 | |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 102 | memset (&addr, 0, sizeof (addr)); |
ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 103 | addr.sin_family = AF_INET; |
| 104 | |
| 105 | /* create a dummy server */ |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 106 | svr_fd = socket (AF_INET, SOCK_STREAM, 0); |
| 107 | GPR_ASSERT (svr_fd >= 0); |
| 108 | GPR_ASSERT (0 == bind (svr_fd, (struct sockaddr *) &addr, addr_len)); |
| 109 | GPR_ASSERT (0 == listen (svr_fd, 1)); |
ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 110 | |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 111 | gpr_mu_lock (GRPC_POLLSET_MU (&g_pollset)); |
Craig Tiller | cb63a9b | 2015-05-13 09:52:36 -0700 | [diff] [blame] | 112 | connections_complete_before = g_connections_complete; |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 113 | gpr_mu_unlock (GRPC_POLLSET_MU (&g_pollset)); |
Craig Tiller | cb63a9b | 2015-05-13 09:52:36 -0700 | [diff] [blame] | 114 | |
ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 115 | /* connect to it */ |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 116 | GPR_ASSERT (getsockname (svr_fd, (struct sockaddr *) &addr, &addr_len) == 0); |
| 117 | grpc_closure_init (&done, must_succeed, NULL); |
| 118 | grpc_tcp_client_connect (&done, &g_connecting, &g_pollset_set, (struct sockaddr *) &addr, addr_len, gpr_inf_future (GPR_CLOCK_REALTIME), &closure_list); |
ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 119 | |
| 120 | /* await the connection */ |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 121 | do |
| 122 | { |
| 123 | addr_len = sizeof (addr); |
| 124 | r = accept (svr_fd, (struct sockaddr *) &addr, &addr_len); |
| 125 | } |
| 126 | while (r == -1 && errno == EINTR); |
| 127 | GPR_ASSERT (r >= 0); |
| 128 | close (r); |
ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 129 | |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 130 | gpr_mu_lock (GRPC_POLLSET_MU (&g_pollset)); |
Craig Tiller | cb63a9b | 2015-05-13 09:52:36 -0700 | [diff] [blame] | 131 | |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 132 | while (g_connections_complete == connections_complete_before) |
| 133 | { |
| 134 | grpc_pollset_worker worker; |
| 135 | grpc_pollset_work (&g_pollset, &worker, gpr_now (GPR_CLOCK_MONOTONIC), GRPC_TIMEOUT_SECONDS_TO_DEADLINE (5), &closure_list); |
| 136 | gpr_mu_unlock (GRPC_POLLSET_MU (&g_pollset)); |
| 137 | grpc_closure_list_run (&closure_list); |
| 138 | gpr_mu_lock (GRPC_POLLSET_MU (&g_pollset)); |
| 139 | } |
Craig Tiller | cb63a9b | 2015-05-13 09:52:36 -0700 | [diff] [blame] | 140 | |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 141 | gpr_mu_unlock (GRPC_POLLSET_MU (&g_pollset)); |
ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 142 | } |
| 143 | |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 144 | void |
| 145 | test_fails (void) |
| 146 | { |
ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 147 | struct sockaddr_in addr; |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 148 | socklen_t addr_len = sizeof (addr); |
Craig Tiller | cb63a9b | 2015-05-13 09:52:36 -0700 | [diff] [blame] | 149 | int connections_complete_before; |
Craig Tiller | dfff1b8 | 2015-09-21 14:39:57 -0700 | [diff] [blame] | 150 | grpc_closure done; |
Craig Tiller | d9ccbbf | 2015-09-22 09:30:00 -0700 | [diff] [blame] | 151 | grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT; |
ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 152 | |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 153 | gpr_log (GPR_DEBUG, "test_fails"); |
Craig Tiller | e959335 | 2015-07-15 07:35:09 -0700 | [diff] [blame] | 154 | |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 155 | memset (&addr, 0, sizeof (addr)); |
ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 156 | addr.sin_family = AF_INET; |
| 157 | |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 158 | gpr_mu_lock (GRPC_POLLSET_MU (&g_pollset)); |
Craig Tiller | cb63a9b | 2015-05-13 09:52:36 -0700 | [diff] [blame] | 159 | connections_complete_before = g_connections_complete; |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 160 | gpr_mu_unlock (GRPC_POLLSET_MU (&g_pollset)); |
Craig Tiller | cb63a9b | 2015-05-13 09:52:36 -0700 | [diff] [blame] | 161 | |
ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 162 | /* connect to a broken address */ |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 163 | grpc_closure_init (&done, must_fail, NULL); |
| 164 | grpc_tcp_client_connect (&done, &g_connecting, &g_pollset_set, (struct sockaddr *) &addr, addr_len, gpr_inf_future (GPR_CLOCK_REALTIME), &closure_list); |
ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 165 | |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 166 | gpr_mu_lock (GRPC_POLLSET_MU (&g_pollset)); |
Craig Tiller | cb63a9b | 2015-05-13 09:52:36 -0700 | [diff] [blame] | 167 | |
ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 168 | /* wait for the connection callback to finish */ |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 169 | while (g_connections_complete == connections_complete_before) |
| 170 | { |
| 171 | grpc_pollset_worker worker; |
| 172 | grpc_pollset_work (&g_pollset, &worker, gpr_now (GPR_CLOCK_MONOTONIC), test_deadline (), &closure_list); |
| 173 | gpr_mu_unlock (GRPC_POLLSET_MU (&g_pollset)); |
| 174 | grpc_closure_list_run (&closure_list); |
| 175 | gpr_mu_lock (GRPC_POLLSET_MU (&g_pollset)); |
| 176 | } |
Craig Tiller | cb63a9b | 2015-05-13 09:52:36 -0700 | [diff] [blame] | 177 | |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 178 | gpr_mu_unlock (GRPC_POLLSET_MU (&g_pollset)); |
ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 179 | } |
| 180 | |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 181 | void |
| 182 | test_times_out (void) |
| 183 | { |
ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 184 | struct sockaddr_in addr; |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 185 | socklen_t addr_len = sizeof (addr); |
ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 186 | int svr_fd; |
Craig Tiller | e959335 | 2015-07-15 07:35:09 -0700 | [diff] [blame] | 187 | #define NUM_CLIENT_CONNECTS 100 |
ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 188 | int client_fd[NUM_CLIENT_CONNECTS]; |
| 189 | int i; |
| 190 | int r; |
Craig Tiller | cb63a9b | 2015-05-13 09:52:36 -0700 | [diff] [blame] | 191 | int connections_complete_before; |
ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 192 | gpr_timespec connect_deadline; |
Craig Tiller | dfff1b8 | 2015-09-21 14:39:57 -0700 | [diff] [blame] | 193 | grpc_closure done; |
Craig Tiller | d9ccbbf | 2015-09-22 09:30:00 -0700 | [diff] [blame] | 194 | grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT; |
ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 195 | |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 196 | gpr_log (GPR_DEBUG, "test_times_out"); |
Craig Tiller | e959335 | 2015-07-15 07:35:09 -0700 | [diff] [blame] | 197 | |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 198 | memset (&addr, 0, sizeof (addr)); |
ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 199 | addr.sin_family = AF_INET; |
| 200 | |
| 201 | /* create a dummy server */ |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 202 | svr_fd = socket (AF_INET, SOCK_STREAM, 0); |
| 203 | GPR_ASSERT (svr_fd >= 0); |
| 204 | GPR_ASSERT (0 == bind (svr_fd, (struct sockaddr *) &addr, addr_len)); |
| 205 | GPR_ASSERT (0 == listen (svr_fd, 1)); |
ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 206 | /* Get its address */ |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 207 | GPR_ASSERT (getsockname (svr_fd, (struct sockaddr *) &addr, &addr_len) == 0); |
ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 208 | |
| 209 | /* tie up the listen buffer, which is somewhat arbitrarily sized. */ |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 210 | for (i = 0; i < NUM_CLIENT_CONNECTS; ++i) |
| 211 | { |
| 212 | client_fd[i] = socket (AF_INET, SOCK_STREAM, 0); |
| 213 | grpc_set_socket_nonblocking (client_fd[i], 1); |
| 214 | do |
| 215 | { |
| 216 | r = connect (client_fd[i], (struct sockaddr *) &addr, addr_len); |
| 217 | } |
| 218 | while (r == -1 && errno == EINTR); |
| 219 | GPR_ASSERT (r < 0); |
| 220 | GPR_ASSERT (errno == EWOULDBLOCK || errno == EINPROGRESS); |
| 221 | } |
ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 222 | |
| 223 | /* connect to dummy server address */ |
| 224 | |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 225 | connect_deadline = GRPC_TIMEOUT_SECONDS_TO_DEADLINE (1); |
ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 226 | |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 227 | gpr_mu_lock (GRPC_POLLSET_MU (&g_pollset)); |
Craig Tiller | cb63a9b | 2015-05-13 09:52:36 -0700 | [diff] [blame] | 228 | connections_complete_before = g_connections_complete; |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 229 | gpr_mu_unlock (GRPC_POLLSET_MU (&g_pollset)); |
ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 230 | |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 231 | grpc_closure_init (&done, must_fail, NULL); |
| 232 | grpc_tcp_client_connect (&done, &g_connecting, &g_pollset_set, (struct sockaddr *) &addr, addr_len, connect_deadline, &closure_list); |
Craig Tiller | cb63a9b | 2015-05-13 09:52:36 -0700 | [diff] [blame] | 233 | |
| 234 | /* Make sure the event doesn't trigger early */ |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 235 | gpr_mu_lock (GRPC_POLLSET_MU (&g_pollset)); |
| 236 | for (;;) |
| 237 | { |
| 238 | grpc_pollset_worker worker; |
| 239 | gpr_timespec now = gpr_now (connect_deadline.clock_type); |
| 240 | gpr_timespec continue_verifying_time = gpr_time_from_seconds (5, GPR_TIMESPAN); |
| 241 | gpr_timespec grace_time = gpr_time_from_seconds (3, GPR_TIMESPAN); |
| 242 | gpr_timespec finish_time = gpr_time_add (connect_deadline, continue_verifying_time); |
| 243 | gpr_timespec restart_verifying_time = gpr_time_add (connect_deadline, grace_time); |
| 244 | int is_after_deadline = gpr_time_cmp (now, connect_deadline) > 0; |
| 245 | if (gpr_time_cmp (now, finish_time) > 0) |
| 246 | { |
| 247 | break; |
| 248 | } |
| 249 | gpr_log (GPR_DEBUG, "now=%d.%09d connect_deadline=%d.%09d", now.tv_sec, now.tv_nsec, connect_deadline.tv_sec, connect_deadline.tv_nsec); |
| 250 | if (is_after_deadline && gpr_time_cmp (now, restart_verifying_time) <= 0) |
| 251 | { |
| 252 | /* allow some slack before insisting that things be done */ |
| 253 | } |
| 254 | else |
| 255 | { |
| 256 | GPR_ASSERT (g_connections_complete == connections_complete_before + is_after_deadline); |
| 257 | } |
| 258 | grpc_pollset_work (&g_pollset, &worker, gpr_now (GPR_CLOCK_MONOTONIC), GRPC_TIMEOUT_MILLIS_TO_DEADLINE (10), &closure_list); |
| 259 | gpr_mu_unlock (GRPC_POLLSET_MU (&g_pollset)); |
| 260 | grpc_closure_list_run (&closure_list); |
| 261 | gpr_mu_lock (GRPC_POLLSET_MU (&g_pollset)); |
Craig Tiller | be95249 | 2015-08-25 16:59:00 -0700 | [diff] [blame] | 262 | } |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 263 | gpr_mu_unlock (GRPC_POLLSET_MU (&g_pollset)); |
Craig Tiller | cb63a9b | 2015-05-13 09:52:36 -0700 | [diff] [blame] | 264 | |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 265 | close (svr_fd); |
| 266 | for (i = 0; i < NUM_CLIENT_CONNECTS; ++i) |
| 267 | { |
| 268 | close (client_fd[i]); |
| 269 | } |
ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 270 | } |
| 271 | |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 272 | static void |
Craig Tiller | 1be70cc | 2015-09-22 10:45:28 -0700 | [diff] [blame^] | 273 | destroy_pollset (grpc_exec_ctx * exec_ctx, void *p, int success) |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 274 | { |
| 275 | grpc_pollset_destroy (p); |
Craig Tiller | dfff1b8 | 2015-09-21 14:39:57 -0700 | [diff] [blame] | 276 | } |
Craig Tiller | cb63a9b | 2015-05-13 09:52:36 -0700 | [diff] [blame] | 277 | |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 278 | int |
| 279 | main (int argc, char **argv) |
| 280 | { |
Craig Tiller | dfff1b8 | 2015-09-21 14:39:57 -0700 | [diff] [blame] | 281 | grpc_closure destroyed; |
Craig Tiller | d9ccbbf | 2015-09-22 09:30:00 -0700 | [diff] [blame] | 282 | grpc_closure_list closure_list = GRPC_CLOSURE_LIST_INIT; |
Craig Tiller | 45724b3 | 2015-09-22 10:42:19 -0700 | [diff] [blame] | 283 | grpc_test_init (argc, argv); |
| 284 | grpc_init (); |
| 285 | grpc_pollset_set_init (&g_pollset_set); |
| 286 | grpc_pollset_init (&g_pollset); |
| 287 | grpc_pollset_set_add_pollset (&g_pollset_set, &g_pollset, &closure_list); |
| 288 | grpc_closure_list_run (&closure_list); |
| 289 | test_succeeds (); |
| 290 | gpr_log (GPR_ERROR, "End of first test"); |
| 291 | test_fails (); |
| 292 | test_times_out (); |
| 293 | grpc_pollset_set_destroy (&g_pollset_set); |
| 294 | grpc_closure_init (&destroyed, destroy_pollset, &g_pollset); |
| 295 | grpc_pollset_shutdown (&g_pollset, &destroyed, &closure_list); |
| 296 | grpc_closure_list_run (&closure_list); |
| 297 | grpc_shutdown (); |
ctiller | 18b49ab | 2014-12-09 14:39:16 -0800 | [diff] [blame] | 298 | return 0; |
Craig Tiller | 190d360 | 2015-02-18 09:23:38 -0800 | [diff] [blame] | 299 | } |