citadel/utils/loadtest.c

   1 // Load testing utility for Citadel Server
   2 //
   3 // Copyright (c) 1987-2023 by the citadel.org team
   4 //
   5 // This program is open source software.  Use, duplication, or disclosure
   6 // is subject to the terms of the GNU General Public License, version 3.
   7
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <unistd.h>
  11 #include <sys/types.h>
  12 #include <sys/wait.h>
  13 #include <string.h>
  14 #include <fcntl.h>
  15 #include <stdio.h>
  16 #include <ctype.h>
  17 #include <signal.h>
  18 #include <errno.h>
  19 #include <limits.h>
  20 #include <sys/socket.h>
  21 #include <sys/un.h>
  22 #include <pthread.h>
  23 #include "../server/citadel_defs.h"
  24 #include "../server/server.h"
  25 #include "../server/citadel_dirs.h"
  26 #include <libcitadel.h>
  27
  28 char ctdldir[PATH_MAX]=CTDLDIR;
  29
  30 char *words[] = {
  31         "lorem","ipsum","dolor","sit","amet","consectetuer","adipiscing","elit","integer","in","mi","a","mauris",
  32         "ornare","sagittis","suspendisse","potenti","suspendisse","dapibus","dignissim","dolor","nam",
  33         "sapien","tellus","tempus","et","tempus","ac","tincidunt","in","arcu","duis","dictum","proin","magna",
  34         "nulla","pellentesque","non","commodo","et","iaculis","sit","amet","mi","mauris","condimentum","massa",
  35         "ut","metus","donec","viverra","sapien","mattis","rutrum","tristique","lacus","eros","semper","tellus",
  36         "et","molestie","nisi","sapien","eu","massa","vestibulum","ante","ipsum","primis","in","faucibus","orci",
  37         "luctus","et","ultrices","posuere","cubilia","curae;","fusce","erat","tortor","mollis","ut","accumsan",
  38         "ut","lacinia","gravida","libero","curabitur","massa","felis","accumsan","feugiat","convallis","sit",
  39         "amet","porta","vel","neque","duis","et","ligula","non","elit","ultricies","rutrum","suspendisse",
  40         "tempor","quisque","posuere","malesuada","velit","sed","pellentesque","mi","a","purus","integer",
  41         "imperdiet","orci","a","eleifend","mollis","velit","nulla","iaculis","arcu","eu","rutrum","magna","quam",
  42         "sed","elit","nullam","egestas","integer","interdum","purus","nec","mauris","vestibulum","ac","mi","in",
  43         "nunc","suscipit","dapibus","duis","consectetuer","ipsum","et","pharetra","sollicitudin","metus",
  44         "turpis","facilisis","magna","vitae","dictum","ligula","nulla","nec","mi","nunc","ante","urna","gravida",
  45         "sit","amet","congue","et","accumsan","vitae","magna","praesent","luctus","nullam","in","velit",
  46         "praesent","est","curabitur","turpis","class","aptent","taciti","sociosqu","ad","litora","torquent",
  47         "per","conubia","nostra","per","inceptos","hymenaeos","cras","consectetuer","nibh","in","lacinia",
  48         "ornare","turpis","sem","tempor","massa","sagittis","feugiat","mauris","nibh","non","tellus",
  49         "phasellus","mi","fusce","enim","mauris","ultrices","turpis","eu","adipiscing","viverra","justo",
  50         "libero","ullamcorper","massa","id","ultrices","velit","est","quis","tortor","quisque","condimentum",
  51         "lacus","volutpat","nonummy","accumsan","est","nunc","imperdiet","magna","vulputate","aliquet","nisi",
  52         "risus","at","est","aliquam","imperdiet","gravida","tortor","praesent","interdum","accumsan","ante",
  53         "vivamus","est","ligula","consequat","sed","pulvinar","eu","consequat","vitae","eros","nulla","elit",
  54         "nunc","congue","eget","scelerisque","a","tempor","ac","nisi","morbi","facilisis","pellentesque",
  55         "habitant","morbi","tristique","senectus","et","netus","et","malesuada","fames","ac","turpis","egestas",
  56         "in","hac","habitasse","platea","dictumst","suspendisse","vel","lorem","ut","ligula","tempor",
  57         "consequat","quisque","consectetuer","nisl","eget","elit","proin","quis","mauris","ac","orci",
  58         "accumsan","suscipit","sed","ipsum","sed","vel","libero","nec","elit","feugiat","blandit","vestibulum",
  59         "purus","nulla","accumsan","et","volutpat","at","pellentesque","vel","urna","suspendisse","nonummy",
  60         "aliquam","pulvinar","libero","donec","vulputate","orci","ornare","bibendum","condimentum","lorem",
  61         "elit","dignissim","sapien","ut","aliquam","nibh","augue","in","turpis","phasellus","ac","eros",
  62         "praesent","luctus","lorem","a","mollis","lacinia","leo","turpis","commodo","sem","in","lacinia","mi",
  63         "quam","et","quam","curabitur","a","libero","vel","tellus","mattis","imperdiet","in","congue","neque","ut",
  64         "scelerisque","bibendum","libero","lacus","ullamcorper","sapien","quis","aliquet","massa","velit",
  65         "vel","orci","fusce","in","nulla","quis","est","cursus","gravida","in","nibh","lorem","ipsum","dolor","sit",
  66         "amet","consectetuer","adipiscing","elit","integer","fermentum","pretium","massa","morbi","feugiat",
  67         "iaculis","nunc","aenean","aliquam","pretium","orci","cum","sociis","natoque","penatibus","et","magnis",
  68         "dis","parturient","montes","nascetur","ridiculus","mus","vivamus","quis","tellus","vel","quam",
  69         "varius","bibendum","fusce","est","metus","feugiat","at","porttitor","et","cursus","quis","pede","nam","ut",
  70         "augue","nulla","posuere","phasellus","at","dolor","a","enim","cursus","vestibulum","duis","id","nisi",
  71         "duis","semper","tellus","ac","nulla","vestibulum","scelerisque","lobortis","dolor","aenean","a",
  72         "felis","aliquam","erat","volutpat","donec","a","magna","vitae","pede","sagittis","lacinia","cras",
  73         "vestibulum","diam","ut","arcu","mauris","a","nunc","duis","sollicitudin","erat","sit","amet","turpis",
  74         "proin","at","libero","eu","diam","lobortis","fermentum","nunc","lorem","turpis","imperdiet","id",
  75         "gravida","eget","aliquet","sed","purus","ut","vehicula","laoreet","ante","mauris","eu","nunc","sed","sit",
  76         "amet","elit","nec","ipsum","aliquam","egestas","donec","non","nibh","cras","sodales","pretium","massa",
  77         "praesent","hendrerit","est","et","risus","vivamus","eget","pede","curabitur","tristique",
  78         "scelerisque","dui","nullam","ullamcorper","vivamus","venenatis","velit","eget","enim","nunc","eu",
  79         "nunc","eget","felis","malesuada","fermentum","quisque","magna","mauris","ligula","felis","luctus","a",
  80         "aliquet","nec","vulputate","eget","magna","quisque","placerat","diam","sed","arcu","praesent",
  81         "sollicitudin","aliquam","non","sapien","quisque","id","augue","class","aptent","taciti","sociosqu",
  82         "ad","litora","torquent","per","conubia","nostra","per","inceptos","hymenaeos","etiam","lacus","lectus",
  83         "mollis","quis","mattis","nec","commodo","facilisis","nibh","sed","sodales","sapien","ac","ante","duis",
  84         "eget","lectus","in","nibh","lacinia","auctor","fusce","interdum","lectus","non","dui","integer",
  85         "accumsan","quisque","quam","curabitur","scelerisque","imperdiet","nisl","suspendisse","potenti",
  86         "nam","massa","leo","iaculis","sed","accumsan","id","ultrices","nec","velit","suspendisse","potenti",
  87         "mauris","bibendum","turpis","ac","viverra","sollicitudin","metus","massa","interdum","orci","non",
  88         "imperdiet","orci","ante","at","ipsum","etiam","eget","magna","mauris","at","tortor","eu","lectus",
  89         "tempor","tincidunt","phasellus","justo","purus","pharetra","ut","ultricies","nec","consequat","vel",
  90         "nisi","fusce","vitae","velit","at","libero","sollicitudin","sodales","aenean","mi","libero","ultrices",
  91         "id","suscipit","vitae","dapibus","eu","metus","aenean","vestibulum","nibh","ac","massa","vivamus",
  92         "vestibulum","libero","vitae","purus","in","hac","maga","habitasse","platea","dictumst","curabitur",
  93         "blandit","nunc","non","arcu","ut","nec","nibh","morbi","quis","leo","vel","magna","commodo","rhoncus",
  94         "donec","congue","leo","eu","lacus","pellentesque","at","erat","id","mi","consequat","congue","praesent",
  95         "a","nisl","ut","diam","interdum","molestie","fusce","suscipit","rhoncus","sem","donec","pretium",
  96         "aliquam","molestie","vivamus","et","justo","at","augue","aliquet","dapibus","pellentesque","felis",
  97         "morbi","semper","in","venenatis","imperdiet","neque","donec","auctor","molestie","augue","nulla","id",
  98         "arcu","sit","amet","dui","lacinia","convallis","proin","tincidunt","proin","a","ante","nunc","imperdiet",
  99         "augue","nullam","sit","amet","arcu","quisque","laoreet","viverra","felis","lorem","ipsum","dolor","sit",
 100         "amet","consectetuer","adipiscing","elit","in","hac","habitasse","platea","dictumst","pellentesque",
 101         "habitant","morbi","tristique","senectus","et","netus","et","malesuada","fames","ac","turpis","egestas",
 102         "class","aptent","taciti","sociosqu","ad","litora","torquent","per","conubia","nostra","per","inceptos",
 103         "hymenaeos","nullam","nibh","sapien","volutpat","ut","placerat","quis","ornare","at","lorem","class",
 104         "aptent","taciti","sociosqu","ad","litora","torquent","per","conubia","nostra","per","inceptos",
 105         "hymenaeos","morbi","dictum","massa","id","libero","ut","neque","phasellus","tincidunt","nibh","ut",
 106         "tincidunt","lacinia","lacus","nulla","aliquam","mi","a","interdum","dui","augue","non","pede","duis",
 107         "nunc","magna","vulputate","a","porta","at","tincidunt","a","nulla","praesent","facilisis",
 108         "suspendisse","sodales","feugiat","purus","cras","et","justo","a","mauris","mollis","imperdiet","morbi",
 109         "erat","mi","ultrices","eget","aliquam","elementum","iaculis","id","velit","in","scelerisque","enim",
 110         "sit","amet","turpis","sed","aliquam","odio","nonummy","ullamcorper","mollis","lacus","nibh","tempor",
 111         "dolor","sit","amet","varius","sem","neque","ac","dui","nunc","et","est","eu","massa","eleifend","mollis",
 112         "mauris","aliquet","orci","quis","tellus","ut","mattis","praesent","mollis","consectetuer","quam",
 113         "nulla","nulla","nunc","accumsan","nunc","sit","amet","scelerisque","porttitor","nibh","pede","lacinia",
 114         "justo","tristique","mattis","purus","eros","non","velit","aenean","sagittis","commodo","erat",
 115         "aliquam","id","lacus","morbi","vulputate","vestibulum","elit"
 116 };
 117 int nwords = sizeof(words) / sizeof(char *);
 118
 119
 120 int uds_connectsock(char *sockpath) {
 121         int s;
 122         struct sockaddr_un addr;
 123
 124         memset(&addr, 0, sizeof(addr));
 125         addr.sun_family = AF_UNIX;
 126         strncpy(addr.sun_path, sockpath, sizeof addr.sun_path);
 127
 128         s = socket(AF_UNIX, SOCK_STREAM, 0);
 129         if (s < 0) {
 130                 return(-1);
 131         }
 132
 133         if (connect(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
 134                 close(s);
 135                 return(-1);
 136         }
 137
 138         return(s);
 139 }
 140
 141
 142 // input binary data from socket
 143 void serv_read(int serv_sock, char *buf, int bytes) {
 144         int len, rlen;
 145
 146         len = 0;
 147         while (len < bytes) {
 148                 rlen = read(serv_sock, &buf[len], bytes - len);
 149                 if (rlen < 1) {
 150                         return;
 151                 }
 152                 len = len + rlen;
 153         }
 154 }
 155
 156
 157 // send binary to server
 158 void serv_write(int serv_sock, char *buf, int nbytes) {
 159         int bytes_written = 0;
 160         int retval;
 161         while (bytes_written < nbytes) {
 162                 retval = write(serv_sock, &buf[bytes_written], nbytes - bytes_written);
 163                 if (retval < 1) {
 164                         return;
 165                 }
 166                 bytes_written = bytes_written + retval;
 167         }
 168 }
 169
 170
 171 // input string from socket - implemented in terms of serv_read()
 172 void serv_gets(int serv_sock, char *buf) {
 173         int i;
 174
 175         // Read one character at a time.
 176         for (i = 0;; i++) {
 177                 serv_read(serv_sock, &buf[i], 1);
 178                 if (buf[i] == '\n' || i == (SIZ-1))
 179                         break;
 180         }
 181
 182         // If we got a long line, discard characters until the newline.
 183         if (i == (SIZ-1)) {
 184                 while (buf[i] != '\n') {
 185                         serv_read(serv_sock, &buf[i], 1);
 186                 }
 187         }
 188
 189         // Strip all trailing nonprintables (crlf)
 190         buf[i] = 0;
 191 }
 192
 193
 194 // send line to server - implemented in terms of serv_write()
 195 void serv_puts(int serv_sock, char *buf) {
 196         serv_write(serv_sock, buf, strlen(buf));
 197         serv_write(serv_sock, "\n", 1);
 198 }
 199
 200
 201
 202 char *random_rooms[] = {
 203         "Load Testing Test Room One",
 204         "Load Test 2: Electric Boogaloo",
 205         "Three shall be the Load Testing",
 206         "This Is The Fourth Load Test Room",
 207         "Five Guys Load Testing and Fries"
 208 };
 209 int nrooms = sizeof(random_rooms) / sizeof(char *);
 210 char *test_user = "Load Test User";
 211 char test_pass[16];
 212
 213
 214 // These are our randomized load test operations: an even mix of changing rooms, posting messages, and deleting messages.
 215 void perform_random_thing(int serv_sock) {
 216         int op = random() % 3;
 217         char buf[SIZ];
 218         int i;
 219         int bigness;
 220
 221         // Random operation 0 : change rooms
 222         if (op == 0) {
 223                 snprintf(buf, sizeof(buf), "GOTO %s", random_rooms[random() % nrooms]);
 224                 serv_puts(serv_sock, buf);
 225                 serv_gets(serv_sock, buf);
 226         }
 227
 228         // Random operation 1 : post a message
 229         if (op == 1) {
 230                 serv_puts(serv_sock, "ENT0 1");
 231                 serv_gets(serv_sock, buf);
 232                 if (buf[0] == '4') {
 233
 234                         bigness = random() % 500;
 235                         strcpy(buf, "");
 236                         for (i=0; i<bigness; ++i) {
 237                                 strcat(buf, words[random() % nwords]);
 238                                 if ( (i != 0) && ((i % 10) == 0) ) {
 239                                         serv_puts(serv_sock, buf);
 240                                         strcpy(buf, "");
 241                                 }
 242                                 else {
 243                                         strcat(buf, " ");
 244                                 }
 245                         }
 246                         serv_puts(serv_sock, buf);
 247                         serv_puts(serv_sock, "000");
 248                 }
 249         }
 250
 251         // Random operation 2 : delete a message
 252         int total_msgs;
 253         long selected_msg;
 254         if (op == 2) {
 255                 total_msgs = 0;
 256                 selected_msg = 0;
 257
 258                 do {
 259                         serv_puts(serv_sock, "MSGS ALL");
 260                         serv_gets(serv_sock, buf);
 261                         if (buf[0] == '1') {
 262                                 while (serv_gets(serv_sock, buf), strcmp(buf, "000")) {
 263                                         ++total_msgs;
 264                                         if ((random() % total_msgs) == 0) {
 265                                                 selected_msg = atol(buf);
 266                                         }
 267                                 }
 268                         }
 269                         snprintf(buf, sizeof buf, "DELE %ld", selected_msg);
 270                         serv_puts(serv_sock, buf);
 271                         serv_gets(serv_sock, buf);
 272                 } while ( (buf[0] != '2') && (total_msgs > 0));
 273         }
 274
 275 }
 276
 277
 278 // This is the main loop.  We log in as the load test user, and then perform random operations until stopped.
 279 void *loadtest(void *blah) {
 280         char buf[SIZ];
 281         int serv_sock;
 282
 283         serv_sock = uds_connectsock(file_citadel_socket);
 284
 285         if (serv_sock < 0) {
 286                 printf("\033[8;0H\033[31mWarning: some threads failed to connect to Citadel Server.\033[0m");
 287                 fflush(stdout);
 288                 pthread_exit(NULL);
 289         }
 290
 291         serv_gets(serv_sock, buf);
 292         snprintf(buf, sizeof buf, "USER %s", test_user);
 293         serv_puts(serv_sock, buf);
 294         serv_gets(serv_sock, buf);
 295         snprintf(buf, sizeof buf, "PASS %s", test_pass);
 296         serv_puts(serv_sock, buf);
 297         serv_gets(serv_sock, buf);
 298         snprintf(buf, sizeof(buf), "GOTO %s", random_rooms[0]);
 299         serv_puts(serv_sock, buf);
 300         serv_gets(serv_sock, buf);
 301
 302         // Find a nice spot on the screen to show the operation count for this thread.
 303         int row = 10 + ((serv_sock-3) % 20);
 304         int col = ((serv_sock-3) / 20) * 10;
 305         long ops = 0;
 306         printf("\033[%d;%dH\033[33m       0\033[0m", row, col);
 307         fflush(stdout);
 308         while(1) {
 309                 perform_random_thing(serv_sock);
 310                 printf("\033[%d;%dH\033[32m%8ld\033[0m", row, col, ++ops);
 311                 fflush(stdout);
 312         }
 313 }
 314
 315
 316 // Create (or replace) the account used for load testing, then create the rooms in which we will load test.
 317 void setup_accounts(int serv_sock) {
 318         int i;
 319         char buf[SIZ];
 320
 321         snprintf(buf, sizeof buf, "CREU %s", test_user);
 322         serv_puts(serv_sock, buf);
 323         serv_gets(serv_sock, buf);
 324         snprintf(buf, sizeof buf, "ASUP %s|%s|0|||6|", test_user, test_pass);
 325         serv_puts(serv_sock, buf);
 326         serv_gets(serv_sock, buf);
 327         snprintf(buf, sizeof buf, "USER %s", test_user);
 328         serv_puts(serv_sock, buf);
 329         serv_gets(serv_sock, buf);
 330         snprintf(buf, sizeof buf, "PASS %s", test_pass);
 331         serv_puts(serv_sock, buf);
 332         serv_gets(serv_sock, buf);
 333
 334         for (i=0; i<nrooms; ++i) {
 335                 snprintf(buf, sizeof buf, "CRE8 1|%s|", random_rooms[i]);
 336                 serv_puts(serv_sock, buf);
 337                 serv_gets(serv_sock, buf);
 338         }
 339 }
 340
 341
 342 // Main loop.  Do things and have fun.
 343 int main(int argc, char **argv) {
 344         int i;
 345         int nthreads = 3;
 346
 347         fprintf(stderr, "\033[2J\033[H"
 348                         "\033[44m\033[33m\033[1m                                                                        \033[K\033[0m\n"
 349                         "\033[44m\033[33m\033[1m Load testing utility for Citadel                                       \033[K\033[0m\n"
 350                         "\033[44m\033[33m\033[1m Copyright (c) 2023 by citadel.org et al.                               \033[K\033[0m\n"
 351                         "\033[44m\033[33m\033[1m This program is open source software.  Use, duplication, or disclosure \033[K\033[0m\n"
 352                         "\033[44m\033[33m\033[1m is subject to the terms of the GNU General Public license v3.          \033[K\033[0m\n"
 353                         "\033[44m\033[33m\033[1m                                                                        \033[K\033[0m\n");
 354
 355         // Parse command line
 356         while ((i = getopt(argc, argv, "h:n:")) != EOF) {
 357                 switch (i) {
 358                 case 'h':
 359                         strncpy(ctdldir, optarg, sizeof ctdldir);
 360                         break;
 361                 case 'n':
 362                         nthreads = atoi(optarg);
 363                         break;
 364                 default:
 365                         fprintf(stderr, "loadtest: usage: %s [-h server_dir] [-n number_of_threads]\n", argv[0]);
 366                         return(1);
 367                 }
 368         }
 369
 370         if (chdir(ctdldir) != 0) {
 371                 fprintf(stderr, "loadtest: %s: %s\n", ctdldir, strerror(errno));
 372                 exit(errno);
 373         }
 374
 375         // Generate a random password for load test user.  No one needs this password except us.
 376         srand(time(NULL)+getpid());
 377         for (i=0; i<sizeof(test_pass)-1; ++i) {
 378                 test_pass[i] = (rand() % 74) + 48;
 379         }
 380         test_pass[sizeof(test_pass)] = 0;
 381
 382         // start connecting
 383         int serv_sock = uds_connectsock(file_citadel_admin_socket);
 384         if (serv_sock < 0) {
 385                 fprintf(stderr, "loadtest: cannot connect to Citadel Server\n");
 386                 exit(1);
 387         }
 388
 389         char buf[SIZ];
 390         serv_gets(serv_sock, buf);
 391         setup_accounts(serv_sock);
 392         close(serv_sock);
 393
 394         for (i=0; i<(nthreads-1); ++i) {
 395
 396                 int row = 10 + ((i+1) % 20);
 397                 int col = ((i+1) / 20) * 10;
 398                 printf("\033[%d;%dH\033[31m--------\033[0m", row, col);
 399                 fflush(stdout);
 400
 401                 pthread_t thread;
 402                 pthread_attr_t attr;
 403                 int ret = 0;
 404
 405                 ret = pthread_attr_init(&attr);
 406                 ret = pthread_attr_setstacksize(&attr, THREADSTACKSIZE);
 407                 ret = pthread_create(&thread, &attr, loadtest, NULL);
 408                 if (ret != 0) {
 409                         exit(ret);
 410                 }
 411
 412         }
 413         loadtest(NULL);
 414
 415         return(0);
 416 }