tests/test-reconnect.c

   1 /*
   2  * Copyright (c) 2009, 2010, 2011, 2012, 2014, 2016 Nicira, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <config.h>
  18 #undef NDEBUG
  19 #include "reconnect.h"
  20 #include <errno.h>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include "command-line.h"
  25 #include "compiler.h"
  26 #include "ovstest.h"
  27 #include "svec.h"
  28 #include "util.h"
  29 #include "openvswitch/vlog.h"
  30
  31 static struct reconnect *reconnect;
  32 static int now;
  33
  34 static void diff_stats(const struct reconnect_stats *old,
  35                        const struct reconnect_stats *new,
  36                        int delta);
  37 static const struct ovs_cmdl_command *get_all_commands(void);
  38
  39 static void
  40 test_reconnect_main(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
  41 {
  42     struct reconnect_stats prev;
  43     unsigned int old_max_tries;
  44     int old_time;
  45     char line[128];
  46
  47     vlog_set_levels_from_string_assert("reconnect:off");
  48
  49     now = 1000;
  50     reconnect = reconnect_create(now);
  51     reconnect_set_name(reconnect, "remote");
  52     reconnect_get_stats(reconnect, now, &prev);
  53     printf("### t=%d ###\n", now);
  54     old_time = now;
  55     old_max_tries = reconnect_get_max_tries(reconnect);
  56     while (fgets(line, sizeof line, stdin)) {
  57         struct reconnect_stats cur;
  58         struct svec args;
  59
  60         fputs(line, stdout);
  61         if (line[0] == '#') {
  62             continue;
  63         }
  64
  65         svec_init(&args);
  66         svec_parse_words(&args, line);
  67         svec_terminate(&args);
  68         if (!svec_is_empty(&args)) {
  69             struct ovs_cmdl_context ctx = {
  70                 .argc = args.n,
  71                 .argv = args.names,
  72             };
  73             ovs_cmdl_run_command(&ctx, get_all_commands());
  74         }
  75         svec_destroy(&args);
  76
  77         if (old_time != now) {
  78             printf("\n### t=%d ###\n", now);
  79         }
  80
  81         reconnect_get_stats(reconnect, now, &cur);
  82         diff_stats(&prev, &cur, now - old_time);
  83         prev = cur;
  84         if (reconnect_get_max_tries(reconnect) != old_max_tries) {
  85             old_max_tries = reconnect_get_max_tries(reconnect);
  86             printf("  %u tries left\n", old_max_tries);
  87         }
  88
  89         old_time = now;
  90     }
  91 }
  92
  93 static void
  94 do_enable(struct ovs_cmdl_context *ctx OVS_UNUSED)
  95 {
  96     reconnect_enable(reconnect, now);
  97 }
  98
  99 static void
 100 do_disable(struct ovs_cmdl_context *ctx OVS_UNUSED)
 101 {
 102     reconnect_disable(reconnect, now);
 103 }
 104
 105 static void
 106 do_force_reconnect(struct ovs_cmdl_context *ctx OVS_UNUSED)
 107 {
 108     reconnect_force_reconnect(reconnect, now);
 109 }
 110
 111 static int
 112 error_from_string(const char *s)
 113 {
 114     if (!s) {
 115         return 0;
 116     } else if (!strcmp(s, "ECONNREFUSED")) {
 117         return ECONNREFUSED;
 118     } else if (!strcmp(s, "EOF")) {
 119         return EOF;
 120     } else {
 121         ovs_fatal(0, "unknown error '%s'", s);
 122     }
 123 }
 124
 125 static void
 126 do_disconnected(struct ovs_cmdl_context *ctx)
 127 {
 128     reconnect_disconnected(reconnect, now, error_from_string(ctx->argv[1]));
 129 }
 130
 131 static void
 132 do_connecting(struct ovs_cmdl_context *ctx OVS_UNUSED)
 133 {
 134     reconnect_connecting(reconnect, now);
 135 }
 136
 137 static void
 138 do_connect_failed(struct ovs_cmdl_context *ctx)
 139 {
 140     reconnect_connect_failed(reconnect, now, error_from_string(ctx->argv[1]));
 141 }
 142
 143 static void
 144 do_connected(struct ovs_cmdl_context *ctx OVS_UNUSED)
 145 {
 146     reconnect_connected(reconnect, now);
 147 }
 148
 149 static void
 150 do_activity(struct ovs_cmdl_context *ctx OVS_UNUSED)
 151 {
 152     reconnect_activity(reconnect, now);
 153 }
 154
 155 static void
 156 do_run(struct ovs_cmdl_context *ctx)
 157 {
 158     enum reconnect_action action;
 159
 160     if (ctx->argc > 1) {
 161         now += atoi(ctx->argv[1]);
 162     }
 163
 164     action = reconnect_run(reconnect, now);
 165     switch (action) {
 166     default:
 167         if (action != 0) {
 168             OVS_NOT_REACHED();
 169         }
 170         break;
 171
 172     case RECONNECT_CONNECT:
 173         printf("  should connect\n");
 174         break;
 175
 176     case RECONNECT_DISCONNECT:
 177         printf("  should disconnect\n");
 178         break;
 179
 180     case RECONNECT_PROBE:
 181         printf("  should send probe\n");
 182         break;
 183     }
 184 }
 185
 186 static void
 187 do_advance(struct ovs_cmdl_context *ctx)
 188 {
 189     now += atoi(ctx->argv[1]);
 190 }
 191
 192 static void
 193 do_timeout(struct ovs_cmdl_context *ctx OVS_UNUSED)
 194 {
 195     int timeout = reconnect_timeout(reconnect, now);
 196     if (timeout >= 0) {
 197         printf("  advance %d ms\n", timeout);
 198         now += timeout;
 199     } else {
 200         printf("  no timeout\n");
 201     }
 202 }
 203
 204 static void
 205 do_set_max_tries(struct ovs_cmdl_context *ctx)
 206 {
 207     reconnect_set_max_tries(reconnect, atoi(ctx->argv[1]));
 208 }
 209
 210 static void
 211 do_set_backoff_free_tries(struct ovs_cmdl_context *ctx)
 212 {
 213     reconnect_set_backoff_free_tries(reconnect, atoi(ctx->argv[1]));
 214 }
 215
 216 static void
 217 diff_stats(const struct reconnect_stats *old,
 218            const struct reconnect_stats *new,
 219            int delta)
 220 {
 221     if (old->state != new->state
 222         || old->state_elapsed != new->state_elapsed
 223         || old->backoff != new->backoff) {
 224         printf("  in %s for %u ms (%d ms backoff)\n",
 225                new->state, new->state_elapsed, new->backoff);
 226     }
 227     if (old->creation_time != new->creation_time
 228         || old->last_activity != new->last_activity
 229         || old->last_connected != new->last_connected) {
 230         printf("  created %lld, last activity %lld, last connected %lld\n",
 231                new->creation_time, new->last_activity, new->last_connected);
 232     }
 233     if (old->n_successful_connections != new->n_successful_connections
 234         || old->n_attempted_connections != new->n_attempted_connections
 235         || old->seqno != new->seqno) {
 236         printf("  %u successful connections out of %u attempts, seqno %u\n",
 237                new->n_successful_connections, new->n_attempted_connections,
 238                new->seqno);
 239     }
 240     if (old->is_connected != new->is_connected) {
 241         printf("  %sconnected\n", new->is_connected ? "" : "dis");
 242     }
 243     if (old->last_connected != new->last_connected
 244         || (old->msec_since_connect != new->msec_since_connect - delta
 245             && !(old->msec_since_connect == UINT_MAX
 246                  && new->msec_since_connect == UINT_MAX))
 247         || (old->total_connected_duration != new->total_connected_duration - delta
 248             && !(old->total_connected_duration == 0
 249                  && new->total_connected_duration == 0))) {
 250         printf("  last connected %u ms ago, connected %u ms total\n",
 251                new->msec_since_connect, new->total_connected_duration);
 252     }
 253     if (old->last_disconnected != new->last_disconnected
 254         || (old->msec_since_disconnect != new->msec_since_disconnect - delta
 255             && !(old->msec_since_disconnect == UINT_MAX
 256                  && new->msec_since_disconnect == UINT_MAX))) {
 257         printf("  disconnected at %llu ms (%u ms ago)\n",
 258                new->last_disconnected, new->msec_since_disconnect);
 259     }
 260 }
 261
 262 static void
 263 do_set_passive(struct ovs_cmdl_context *ctx OVS_UNUSED)
 264 {
 265     reconnect_set_passive(reconnect, true, now);
 266 }
 267
 268 static void
 269 do_listening(struct ovs_cmdl_context *ctx OVS_UNUSED)
 270 {
 271     reconnect_listening(reconnect, now);
 272 }
 273
 274 static void
 275 do_listen_error(struct ovs_cmdl_context *ctx)
 276 {
 277     reconnect_listen_error(reconnect, now, atoi(ctx->argv[1]));
 278 }
 279
 280 static const struct ovs_cmdl_command all_commands[] = {
 281     { "enable", NULL, 0, 0, do_enable, OVS_RO },
 282     { "disable", NULL, 0, 0, do_disable, OVS_RO },
 283     { "force-reconnect", NULL, 0, 0, do_force_reconnect, OVS_RO },
 284     { "disconnected", NULL, 0, 1, do_disconnected, OVS_RO },
 285     { "connecting", NULL, 0, 0, do_connecting, OVS_RO },
 286     { "connect-failed", NULL, 0, 1, do_connect_failed, OVS_RO },
 287     { "connected", NULL, 0, 0, do_connected, OVS_RO },
 288     { "activity", NULL, 0, 0, do_activity, OVS_RO },
 289     { "run", NULL, 0, 1, do_run, OVS_RO },
 290     { "advance", NULL, 1, 1, do_advance, OVS_RO },
 291     { "timeout", NULL, 0, 0, do_timeout, OVS_RO },
 292     { "set-max-tries", NULL, 1, 1, do_set_max_tries, OVS_RO },
 293     { "set-backoff-free-tries", NULL, 1, 1, do_set_backoff_free_tries,
 294       OVS_RO },
 295     { "passive", NULL, 0, 0, do_set_passive, OVS_RO },
 296     { "listening", NULL, 0, 0, do_listening, OVS_RO },
 297     { "listen-error", NULL, 1, 1, do_listen_error, OVS_RO },
 298     { NULL, NULL, 0, 0, NULL, OVS_RO },
 299 };
 300
 301 static const struct ovs_cmdl_command *
 302 get_all_commands(void)
 303 {
 304     return all_commands;
 305 }
 306
 307 OVSTEST_REGISTER("test-reconnect", test_reconnect_main);