contrib/pwmd-stress-test.c

   1 /*
   2     Copyright (C) 2016-2018 Ben Kibbey <bjk@luxsci.net>
   3
   4     This file is part of libpwmd.
   5
   6     Libpwmd is free software: you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation, either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     Libpwmd is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with Libpwmd.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19 #ifdef HAVE_CONFIG_H
  20 #include <config.h>
  21 #endif
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <unistd.h>
  25 #include <libpwmd.h>
  26 #include <pthread.h>
  27 #include <string.h>
  28
  29 static char *socket, *file, *cmd;
  30 static int remaining;
  31 static pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
  32 static int lock;
  33 static int states;
  34 static int lock_timeout;
  35 static int quiet;
  36
  37 static gpg_error_t
  38 status_cb (void *data, const char *line)
  39 {
  40   pthread_t tid = pthread_self ();
  41
  42   if (quiet < 1)
  43     fprintf(stdout, "STATUS: %p: %s\n", (pthread_t *)tid, line);
  44   return 0;
  45 }
  46
  47 void *
  48 start (void *data)
  49 {
  50   pwm_t *pwm = NULL;
  51   gpg_error_t rc;
  52   pthread_t tid = pthread_self ();
  53   char *result;
  54
  55   if (quiet < 2)
  56     fprintf(stdout, "START: %p\n", (pthread_t *)tid);
  57   rc = pwmd_new ("test-client", &pwm);
  58   if (rc)
  59     goto fail;
  60
  61   pwmd_setopt (pwm, PWMD_OPTION_LOCK_ON_OPEN, lock);
  62   pwmd_setopt (pwm, PWMD_OPTION_STATUS_CB, status_cb);
  63
  64   rc = pwmd_connect (pwm, socket, NULL);
  65   if (rc)
  66     goto fail;
  67
  68   if (lock_timeout)
  69     {
  70       rc = pwmd_command (pwm, NULL, NULL, NULL, NULL, "OPTION lock-timeout=%i",
  71                          lock_timeout);
  72       if (rc)
  73         goto fail;
  74     }
  75
  76   if (states)
  77     {
  78       rc = pwmd_command (pwm, NULL, NULL, NULL, NULL, "OPTION client-state=%i",
  79                          states);
  80       if (rc)
  81         goto fail;
  82     }
  83
  84   rc = pwmd_process (pwm);
  85   if (rc)
  86     goto fail;
  87
  88   if (file)
  89     {
  90       rc = pwmd_open (pwm, file, NULL, NULL);
  91       if (rc)
  92         goto fail;
  93     }
  94
  95   rc = pwmd_process (pwm);
  96   if (rc)
  97     goto fail;
  98
  99   rc = pwmd_command (pwm, &result, NULL, NULL, NULL, cmd);
 100   if (rc)
 101     goto fail;
 102
 103   if (quiet < 1)
 104     fprintf(stdout, "RESULT: %p: '%s'\n", (pthread_t *) tid, result);
 105   pwmd_free (result);
 106   rc = pwmd_process (pwm);
 107
 108 fail:
 109   pwmd_close (pwm);
 110
 111   if (rc && quiet < 3)
 112     fprintf(stdout, "ERROR: %p: %u: %s\n", (pthread_t *)tid, rc,
 113             gpg_strerror(rc));
 114
 115   pthread_mutex_lock (&count_mutex);
 116   remaining--;
 117   pthread_mutex_unlock (&count_mutex);
 118   if (quiet < 2)
 119     fprintf(stdout, "END: %p\n", (pthread_t *)tid);
 120   pthread_exit (NULL);
 121   return NULL;
 122 }
 123
 124 static void
 125 usage (const char *pn, int status)
 126 {
 127   fprintf(status == EXIT_SUCCESS ? stdout : stderr,
 128           "Usage: %s [-hsnq] [-l N] <clients> <socket> [<datafile>] '<command_with_args>'\n", pn);
 129   fprintf(status == EXIT_SUCCESS ? stdout : stderr,
 130           "  -n     don't lock data file mutex\n"
 131           "  -l N   lock timeout in tenths of a second\n"
 132           "  -q     quiet (can be used more than once)\n"
 133           "  -s     receive client state status messages\n"
 134           "  -h     this help text\n");
 135   exit (status);
 136 }
 137
 138 int main(int argc, char **argv)
 139 {
 140   int i;
 141   pthread_attr_t attr;
 142   unsigned nclients;
 143   int opt;
 144
 145   lock = 1;
 146
 147   while ((opt = getopt (argc, argv, "hnsl:q")) != -1)
 148     {
 149       switch (opt)
 150         {
 151         case 'q':
 152           quiet++;
 153           break;
 154         case 'l':
 155           lock_timeout = atoi (optarg);
 156           break;
 157         case 'n':
 158           lock = 0;
 159           break;
 160         case 's':
 161           states = 1;
 162           break;
 163         case 'h':
 164           usage (argv[0], EXIT_SUCCESS);
 165           break;
 166         }
 167     }
 168
 169   if (argc - optind < 3)
 170     usage (argv[0], EXIT_FAILURE);
 171
 172   nclients = atoi (argv[optind++]);
 173   socket = strdup (argv[optind++]);
 174
 175   if ((argc-optind) > 1)
 176     file = strdup (argv[optind++]);
 177
 178   cmd = strdup (argv[optind++]);
 179   if (quiet < 2)
 180     fprintf(stdout, "Doing: '%s'\n", cmd);
 181   pwmd_init ();
 182   pthread_attr_init (&attr);
 183   pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
 184
 185   for (i = 0; i < nclients; i++)
 186     {
 187       pthread_t tid;
 188       int e = pthread_create (&tid, NULL, start, NULL);
 189
 190       if (e)
 191         {
 192           if (quiet < 3)
 193             fprintf(stdout, "%s\n", strerror (e));
 194           continue;
 195         }
 196
 197       pthread_mutex_lock (&count_mutex);
 198       remaining++;
 199       pthread_mutex_unlock (&count_mutex);
 200     }
 201
 202   pthread_attr_destroy (&attr);
 203
 204   for (; remaining;)
 205     {
 206       int n;
 207
 208       pthread_mutex_lock (&count_mutex);
 209       n = remaining;
 210       pthread_mutex_unlock (&count_mutex);
 211
 212       if (quiet < 2)
 213         fprintf(stdout, "%i clients remain ...\n", n);
 214       usleep (100000);
 215     }
 216
 217   pwmd_deinit ();
 218   exit (EXIT_SUCCESS);
 219 }