src/vpp/api/test_ha.c

   1 /*
   2  *------------------------------------------------------------------
   3  * api.c - message handler registration
   4  *
   5  * Copyright (c) 2010 Cisco and/or its affiliates.
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at:
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *------------------------------------------------------------------
  18  */
  19
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <sys/types.h>
  23 #include <sys/mman.h>
  24 #include <sys/stat.h>
  25 #include <netinet/in.h>
  26 #include <signal.h>
  27 #include <pthread.h>
  28 #include <unistd.h>
  29 #include <time.h>
  30 #include <fcntl.h>
  31 #include <string.h>
  32 #include <vppinfra/clib.h>
  33 #include <vppinfra/vec.h>
  34 #include <vppinfra/hash.h>
  35 #include <vppinfra/bitmap.h>
  36 #include <vppinfra/fifo.h>
  37 #include <vppinfra/time.h>
  38 #include <vppinfra/heap.h>
  39 #include <vppinfra/pool.h>
  40 #include <vppinfra/format.h>
  41 #include <vppinfra/error.h>
  42
  43 #include <vnet/vnet.h>
  44 #include <vlib/vlib.h>
  45 #include <vlib/unix/unix.h>
  46 #include <vlibapi/api.h>
  47 #include <vlibmemory/api.h>
  48 #include <svm/svm.h>
  49 #include <svm/svmdb.h>
  50
  51 #include <vpp/api/vpe_msg_enum.h>
  52
  53 #include <vnet/ip/ip.h>
  54
  55 #define f64_endian(a)
  56 #define f64_print(a,b)
  57
  58 #define vl_typedefs             /* define message structures */
  59 #include <vpp/api/vpe_all_api_h.h>
  60 #undef vl_typedefs
  61
  62 #define vl_endianfun            /* define message structures */
  63 #include <vpp/api/vpe_all_api_h.h>
  64 #undef vl_endianfun
  65
  66 /* instantiate all the print functions we know about */
  67 #define vl_print(handle, ...)
  68 #define vl_printfun
  69 #include <vpp/api/vpe_all_api_h.h>
  70 #undef vl_printfun
  71
  72 vl_shmem_hdr_t *shmem_hdr;
  73
  74 typedef struct
  75 {
  76   u32 pings_sent;
  77   u32 pings_replied;
  78   volatile u32 signal_received;
  79
  80   /* convenience */
  81   svm_queue_t *vl_input_queue;
  82   u32 my_client_index;
  83   svmdb_client_t *svmdb_client;
  84 } test_main_t;
  85
  86 test_main_t test_main;
  87
  88 static void vl_api_control_ping_reply_t_handler
  89   (vl_api_control_ping_reply_t * mp)
  90 {
  91   test_main_t *tm = &test_main;
  92
  93   fformat (stdout, "control ping reply from pid %d\n", ntohl (mp->vpe_pid));
  94   tm->pings_replied++;
  95 }
  96
  97 vlib_main_t vlib_global_main;
  98 vlib_main_t **vlib_mains;
  99
 100 void
 101 vlib_cli_output (struct vlib_main_t *vm, char *fmt, ...)
 102 {
 103   clib_warning ("BUG: vlib_cli_output called...");
 104 }
 105
 106 #define foreach_api_msg                         \
 107 _(CONTROL_PING_REPLY,control_ping_reply)
 108
 109 void
 110 ping (test_main_t * tm)
 111 {
 112   vl_api_control_ping_t *mp;
 113
 114   mp = vl_msg_api_alloc (sizeof (*mp));
 115   clib_memset (mp, 0, sizeof (*mp));
 116   mp->_vl_msg_id = ntohs (VL_API_CONTROL_PING);
 117   mp->client_index = tm->my_client_index;
 118   mp->context = 0xdeadbeef;
 119
 120   vl_msg_api_send_shmem (tm->vl_input_queue, (u8 *) & mp);
 121 }
 122
 123 static void
 124 noop_handler (void *notused)
 125 {
 126 }
 127
 128 int
 129 connect_to_vpe (char *name)
 130 {
 131   int rv = 0;
 132   test_main_t *tm = &test_main;
 133   api_main_t *am = vlibapi_get_main ();
 134
 135   rv = vl_client_connect_to_vlib ("/vpe-api", name, 32);
 136   if (rv < 0)
 137     return rv;
 138
 139 #define _(N,n)                                                  \
 140     vl_msg_api_set_handlers(VL_API_##N, #n,                     \
 141                            vl_api_##n##_t_handler,              \
 142                            noop_handler,                        \
 143                            vl_api_##n##_t_endian,               \
 144                            vl_api_##n##_t_print,                \
 145                            sizeof(vl_api_##n##_t), 1);
 146   foreach_api_msg;
 147 #undef _
 148
 149   shmem_hdr = api_main.shmem_hdr;
 150   tm->vl_input_queue = shmem_hdr->vl_input_queue;
 151   tm->my_client_index = am->my_client_index;
 152   return 0;
 153 }
 154
 155 int
 156 disconnect_from_vpe (void)
 157 {
 158   vl_client_disconnect_from_vlib ();
 159
 160   return 0;
 161 }
 162
 163 void
 164 signal_handler (int signo)
 165 {
 166   test_main_t *tm = &test_main;
 167
 168   tm->signal_received = 1;
 169 }
 170
 171
 172 int
 173 main (int argc, char **argv)
 174 {
 175   test_main_t *tm = &test_main;
 176   api_main_t *am = vlibapi_get_main ();
 177   u32 swt_pid = 0;
 178   int connected = 0;
 179
 180   signal (SIGINT, signal_handler);
 181
 182   while (1)
 183     {
 184       if (tm->signal_received)
 185         break;
 186
 187       if (am->shmem_hdr)
 188         swt_pid = am->shmem_hdr->vl_pid;
 189
 190       /* If kill returns 0, the vpe-f process is alive */
 191       if (kill (swt_pid, 0) == 0)
 192         {
 193           /* Try to connect */
 194           if (connected == 0)
 195             {
 196               fformat (stdout, "Connect to VPE-f\n");
 197               if (connect_to_vpe ("test_ha_client") >= 0)
 198                 {
 199                   tm->pings_sent = 0;
 200                   tm->pings_replied = 0;
 201                   connected = 1;
 202                 }
 203               else
 204                 {
 205                   fformat (stdout, "Connect failed, sleep and retry...\n");
 206                   sleep (1);
 207                   continue;
 208                 }
 209             }
 210           tm->pings_sent++;
 211           ping (tm);
 212
 213           sleep (1);
 214
 215           /* havent heard back in 3 seconds, disco / reco */
 216           if ((tm->pings_replied + 3) <= tm->pings_sent)
 217             {
 218               fformat (stdout, "VPE-f pid %d not responding\n", swt_pid);
 219               swt_pid = 0;
 220               disconnect_from_vpe ();
 221               connected = 0;
 222             }
 223         }
 224       else
 225         {
 226           if (connected)
 227             {
 228               fformat (stdout, "VPE-f pid %d died\n", swt_pid);
 229               swt_pid = 0;
 230               disconnect_from_vpe ();
 231               connected = 0;
 232             }
 233           sleep (1);
 234         }
 235     }
 236
 237   fformat (stdout, "Signal received, graceful exit\n");
 238   disconnect_from_vpe ();
 239   exit (0);
 240 }
 241
 242 /*
 243  * fd.io coding-style-patch-verification: ON
 244  *
 245  * Local Variables:
 246  * eval: (c-set-style "gnu")
 247  * End:
 248  */