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          * mutex to lock running field
  82          */
  83         mutex_t *mutex;
  84
  85         /**
  86          * condvar to wait for initiators
  87          */
  88         condvar_t *condvar;
  89 };
  90
  91 /**
  92  * Begin the load test
  93  */
  94 static job_requeue_t do_load_test(private_load_tester_plugin_t *this)
  95 {
  96         int i, s = 0, ms = 0;
  97
  98         this->mutex->lock(this->mutex);
  99         if (!this->running)
 100         {
 101                 this->running = this->initiators;
 102         }
 103         this->mutex->unlock(this->mutex);
 104         if (this->delay)
 105         {
 106                 s = this->delay / 1000;
 107                 ms = this->delay % 1000;
 108         }
 109
 110         for (i = 0; this->iterations == 0 || i < this->iterations; i++)
 111         {
 112                 peer_cfg_t *peer_cfg;
 113                 child_cfg_t *child_cfg = NULL;
 114                 enumerator_t *enumerator;
 115
 116                 peer_cfg = charon->backends->get_peer_cfg_by_name(charon->backends,
 117                                                                                                                   "load-test");
 118                 if (!peer_cfg)
 119                 {
 120                         break;
 121                 }
 122                 enumerator = peer_cfg->create_child_cfg_enumerator(peer_cfg);
 123                 if (!enumerator->enumerate(enumerator, &child_cfg))
 124                 {
 125                         enumerator->destroy(enumerator);
 126                         break;
 127                 }
 128                 enumerator->destroy(enumerator);
 129
 130                 charon->controller->initiate(charon->controller,
 131                                         peer_cfg, child_cfg->get_ref(child_cfg),
 132                                         NULL, NULL);
 133                 if (s)
 134                 {
 135                         sleep(s);
 136                 }
 137                 if (ms)
 138                 {
 139                         usleep(ms * 1000);
 140                 }
 141         }
 142         this->mutex->lock(this->mutex);
 143         this->running--;
 144         this->mutex->unlock(this->mutex);
 145         this->condvar->signal(this->condvar);
 146         return JOB_REQUEUE_NONE;
 147 }
 148
 149 METHOD(plugin_t, destroy, void,
 150         private_load_tester_plugin_t *this)
 151 {
 152         this->iterations = -1;
 153         this->mutex->lock(this->mutex);
 154         while (this->running)
 155         {
 156                 this->condvar->wait(this->condvar, this->mutex);
 157         }
 158         this->mutex->unlock(this->mutex);
 159         hydra->kernel_interface->remove_ipsec_interface(hydra->kernel_interface,
 160                                                 (kernel_ipsec_constructor_t)load_tester_ipsec_create);
 161         charon->backends->remove_backend(charon->backends, &this->config->backend);
 162         lib->credmgr->remove_set(lib->credmgr, &this->creds->credential_set);
 163         charon->bus->remove_listener(charon->bus, &this->listener->listener);
 164         this->config->destroy(this->config);
 165         this->creds->destroy(this->creds);
 166         this->listener->destroy(this->listener);
 167         lib->crypto->remove_dh(lib->crypto,
 168                                                 (dh_constructor_t)load_tester_diffie_hellman_create);
 169         this->mutex->destroy(this->mutex);
 170         this->condvar->destroy(this->condvar);
 171         free(this);
 172 }
 173
 174 /*
 175  * see header file
 176  */
 177 plugin_t *load_tester_plugin_create()
 178 {
 179         private_load_tester_plugin_t *this;
 180         u_int i, shutdown_on = 0;
 181
 182         if (!lib->settings->get_bool(lib->settings,
 183                                                                  "charon.plugins.load-tester.enable", FALSE))
 184         {
 185                 DBG1(DBG_CFG, "disabling load-tester plugin, not configured");
 186                 return NULL;
 187         }
 188
 189         INIT(this,
 190                 .public = {
 191                         .plugin = {
 192                                 .destroy = _destroy,
 193                         },
 194                 },
 195                 .delay = lib->settings->get_int(lib->settings,
 196                                         "charon.plugins.load-tester.delay", 0),
 197                 .iterations = lib->settings->get_int(lib->settings,
 198                                         "charon.plugins.load-tester.iterations", 1),
 199                 .initiators = lib->settings->get_int(lib->settings,
 200                                         "charon.plugins.load-tester.initiators", 0),
 201                 .mutex = mutex_create(MUTEX_TYPE_DEFAULT),
 202                 .condvar = condvar_create(CONDVAR_TYPE_DEFAULT),
 203                 .config = load_tester_config_create(),
 204                 .creds = load_tester_creds_create(),
 205                 .listener = load_tester_listener_create(shutdown_on),
 206         );
 207
 208         lib->crypto->add_dh(lib->crypto, MODP_NULL, plugin_name,
 209                                                 (dh_constructor_t)load_tester_diffie_hellman_create);
 210         charon->backends->add_backend(charon->backends, &this->config->backend);
 211         lib->credmgr->add_set(lib->credmgr, &this->creds->credential_set);
 212         charon->bus->add_listener(charon->bus, &this->listener->listener);
 213
 214         if (lib->settings->get_bool(lib->settings,
 215                                         "charon.plugins.load-tester.shutdown_when_complete", 0))
 216         {
 217                 shutdown_on = this->iterations * this->initiators;
 218         }
 219
 220
 221         if (lib->settings->get_bool(lib->settings,
 222                                         "charon.plugins.load-tester.fake_kernel", FALSE))
 223         {
 224                 hydra->kernel_interface->add_ipsec_interface(hydra->kernel_interface,
 225                                                 (kernel_ipsec_constructor_t)load_tester_ipsec_create);
 226         }
 227         this->running = 0;
 228         for (i = 0; i < this->initiators; i++)
 229         {
 230                 lib->processor->queue_job(lib->processor,
 231                                         (job_t*)callback_job_create((callback_job_cb_t)do_load_test,
 232                                                                                                 this, NULL, NULL));
 233         }
 234         return &this->public.plugin;
 235 }
 236