src/libcharon/plugins/load_tester/load_tester_plugin.c

   1 /*
   2  * Copyright (C) 2008 Martin Willi
   3  * Hochschule fuer Technik Rapperswil
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License as published by the
   7  * Free Software Foundation; either version 2 of the License, or (at your
   8  * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  12  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13  * for more details.
  14  */
  15
  16 #include "load_tester_plugin.h"
  17 #include "load_tester_config.h"
  18 #include "load_tester_creds.h"
  19 #include "load_tester_ipsec.h"
  20 #include "load_tester_listener.h"
  21 #include "load_tester_diffie_hellman.h"
  22
  23 #include <unistd.h>
  24
  25 #include <hydra.h>
  26 #include <daemon.h>
  27 #include <processing/jobs/callback_job.h>
  28 #include <threading/condvar.h>
  29 #include <threading/mutex.h>
  30
  31 static const char *plugin_name = "load_tester";
  32
  33 typedef struct private_load_tester_plugin_t private_load_tester_plugin_t;
  34
  35 /**
  36  * private data of load_tester plugin
  37  */
  38 struct private_load_tester_plugin_t {
  39
  40         /**
  41          * implements plugin interface
  42          */
  43         load_tester_plugin_t public;
  44
  45         /**
  46          * load_tester configuration backend
  47          */
  48         load_tester_config_t *config;
  49
  50         /**
  51          * load_tester credential set implementation
  52          */
  53         load_tester_creds_t *creds;
  54
  55         /**
  56          * event handler, listens on bus
  57          */
  58         load_tester_listener_t *listener;
  59
  60         /**
  61          * number of iterations per thread
  62          */
  63         int iterations;
  64
  65         /**
  66          * number desired initiator threads
  67          */
  68         int initiators;
  69
  70         /**
  71          * currenly running initiators
  72          */
  73         int running;
  74
  75         /**
  76          * delay between initiations, in ms
  77          */
  78         int delay;
  79
  80         /**
  81          * Throttle initiation if half-open IKE_SA count reached
  82          */
  83         int init_limit;
  84
  85         /**
  86          * mutex to lock running field
  87          */
  88         mutex_t *mutex;
  89
  90         /**
  91          * condvar to wait for initiators
  92          */
  93         condvar_t *condvar;
  94 };
  95
  96 /**
  97  * Begin the load test
  98  */
  99 static job_requeue_t do_load_test(private_load_tester_plugin_t *this)
 100 {
 101         int i, s = 0, ms = 0;
 102
 103         this->mutex->lock(this->mutex);
 104         this->running++;
 105         this->mutex->unlock(this->mutex);
 106         if (this->delay)
 107         {
 108                 s = this->delay / 1000;
 109                 ms = this->delay % 1000;
 110         }
 111
 112         for (i = 0; this->iterations == 0 || i < this->iterations; i++)
 113         {
 114                 peer_cfg_t *peer_cfg;
 115                 child_cfg_t *child_cfg = NULL;
 116                 enumerator_t *enumerator;
 117
 118                 if (this->init_limit)
 119                 {
 120                         while ((charon->ike_sa_manager->get_count(charon->ike_sa_manager) -
 121                                                 this->listener->get_established(this->listener)) >
 122                                         this->init_limit)
 123                         {
 124                                 if (s)
 125                                 {
 126                                         sleep(s);
 127                                 }
 128                                 if (ms)
 129                                 {
 130                                         usleep(ms * 1000);
 131                                 }
 132                         }
 133                 }
 134
 135                 peer_cfg = charon->backends->get_peer_cfg_by_name(charon->backends,
 136                                                                                                                   "load-test");
 137                 if (!peer_cfg)
 138                 {
 139                         break;
 140                 }
 141                 enumerator = peer_cfg->create_child_cfg_enumerator(peer_cfg);
 142                 if (!enumerator->enumerate(enumerator, &child_cfg))
 143                 {
 144                         enumerator->destroy(enumerator);
 145                         break;
 146                 }
 147                 enumerator->destroy(enumerator);
 148
 149                 charon->controller->initiate(charon->controller,
 150                                         peer_cfg, child_cfg->get_ref(child_cfg),
 151                                         NULL, NULL);
 152                 if (s)
 153                 {
 154                         sleep(s);
 155                 }
 156                 if (ms)
 157                 {
 158                         usleep(ms * 1000);
 159                 }
 160         }
 161         this->mutex->lock(this->mutex);
 162         this->running--;
 163         this->condvar->signal(this->condvar);
 164         this->mutex->unlock(this->mutex);
 165         return JOB_REQUEUE_NONE;
 166 }
 167
 168 METHOD(plugin_t, get_name, char*,
 169         private_load_tester_plugin_t *this)
 170 {
 171         return "load-tester";
 172 }
 173
 174 METHOD(plugin_t, destroy, void,
 175         private_load_tester_plugin_t *this)
 176 {
 177         this->iterations = -1;
 178         this->mutex->lock(this->mutex);
 179         while (this->running)
 180         {
 181                 this->condvar->wait(this->condvar, this->mutex);
 182         }
 183         this->mutex->unlock(this->mutex);
 184         hydra->kernel_interface->remove_ipsec_interface(hydra->kernel_interface,
 185                                                 (kernel_ipsec_constructor_t)load_tester_ipsec_create);
 186         charon->backends->remove_backend(charon->backends, &this->config->backend);
 187         lib->credmgr->remove_set(lib->credmgr, &this->creds->credential_set);
 188         charon->bus->remove_listener(charon->bus, &this->listener->listener);
 189         this->config->destroy(this->config);
 190         this->creds->destroy(this->creds);
 191         this->listener->destroy(this->listener);
 192         lib->crypto->remove_dh(lib->crypto,
 193                                                 (dh_constructor_t)load_tester_diffie_hellman_create);
 194         this->mutex->destroy(this->mutex);
 195         this->condvar->destroy(this->condvar);
 196         free(this);
 197 }
 198
 199 /*
 200  * see header file
 201  */
 202 plugin_t *load_tester_plugin_create()
 203 {
 204         private_load_tester_plugin_t *this;
 205         u_int i, shutdown_on = 0;
 206
 207         if (!lib->settings->get_bool(lib->settings,
 208                                                                  "charon.plugins.load-tester.enable", FALSE))
 209         {
 210                 DBG1(DBG_CFG, "disabling load-tester plugin, not configured");
 211                 return NULL;
 212         }
 213
 214         INIT(this,
 215                 .public = {
 216                         .plugin = {
 217                                 .get_name = _get_name,
 218                                 .reload = (void*)return_false,
 219                                 .destroy = _destroy,
 220                         },
 221                 },
 222                 .delay = lib->settings->get_int(lib->settings,
 223                                         "charon.plugins.load-tester.delay", 0),
 224                 .iterations = lib->settings->get_int(lib->settings,
 225                                         "charon.plugins.load-tester.iterations", 1),
 226                 .initiators = lib->settings->get_int(lib->settings,
 227                                         "charon.plugins.load-tester.initiators", 0),
 228                 .init_limit = lib->settings->get_int(lib->settings,
 229                                         "charon.plugins.load-tester.init_limit", 0),
 230                 .mutex = mutex_create(MUTEX_TYPE_DEFAULT),
 231                 .condvar = condvar_create(CONDVAR_TYPE_DEFAULT),
 232                 .config = load_tester_config_create(),
 233                 .creds = load_tester_creds_create(),
 234         );
 235
 236         lib->crypto->add_dh(lib->crypto, MODP_NULL, plugin_name,
 237                                                 (dh_constructor_t)load_tester_diffie_hellman_create);
 238         charon->backends->add_backend(charon->backends, &this->config->backend);
 239         lib->credmgr->add_set(lib->credmgr, &this->creds->credential_set);
 240
 241         if (lib->settings->get_bool(lib->settings,
 242                                         "charon.plugins.load-tester.shutdown_when_complete", 0))
 243         {
 244                 shutdown_on = this->iterations * this->initiators;
 245         }
 246         this->listener = load_tester_listener_create(shutdown_on);
 247         charon->bus->add_listener(charon->bus, &this->listener->listener);
 248
 249         if (lib->settings->get_bool(lib->settings,
 250                                         "charon.plugins.load-tester.fake_kernel", FALSE))
 251         {
 252                 hydra->kernel_interface->add_ipsec_interface(hydra->kernel_interface,
 253                                                 (kernel_ipsec_constructor_t)load_tester_ipsec_create);
 254         }
 255         for (i = 0; i < this->initiators; i++)
 256         {
 257                 lib->processor->queue_job(lib->processor, (job_t*)
 258                                 callback_job_create_with_prio((callback_job_cb_t)do_load_test,
 259                                                                                 this, NULL, NULL, JOB_PRIO_CRITICAL));
 260         }
 261         return &this->public.plugin;
 262 }
 263