t/helper/test-fsmonitor-client.c

   1 /*
   2  * test-fsmonitor-client.c: client code to send commands/requests to
   3  * a `git fsmonitor--daemon` daemon.
   4  */
   5
   6 #include "test-tool.h"
   7 #include "cache.h"
   8 #include "parse-options.h"
   9 #include "fsmonitor-ipc.h"
  10 #include "thread-utils.h"
  11 #include "trace2.h"
  12
  13 #ifndef HAVE_FSMONITOR_DAEMON_BACKEND
  14 int cmd__fsmonitor_client(int argc, const char **argv)
  15 {
  16         die("fsmonitor--daemon not available on this platform");
  17 }
  18 #else
  19
  20 /*
  21  * Read the `.git/index` to get the last token written to the
  22  * FSMonitor Index Extension.
  23  */
  24 static const char *get_token_from_index(void)
  25 {
  26         struct index_state *istate = the_repository->index;
  27
  28         if (do_read_index(istate, the_repository->index_file, 0) < 0)
  29                 die("unable to read index file");
  30         if (!istate->fsmonitor_last_update)
  31                 die("index file does not have fsmonitor extension");
  32
  33         return istate->fsmonitor_last_update;
  34 }
  35
  36 /*
  37  * Send an IPC query to a `git-fsmonitor--daemon` daemon and
  38  * ask for the changes since the given token or from the last
  39  * token in the index extension.
  40  *
  41  * This will implicitly start a daemon process if necessary.  The
  42  * daemon process will persist after we exit.
  43  */
  44 static int do_send_query(const char *token)
  45 {
  46         struct strbuf answer = STRBUF_INIT;
  47         int ret;
  48
  49         if (!token || !*token)
  50                 token = get_token_from_index();
  51
  52         ret = fsmonitor_ipc__send_query(token, &answer);
  53         if (ret < 0)
  54                 die("could not query fsmonitor--daemon");
  55
  56         write_in_full(1, answer.buf, answer.len);
  57         strbuf_release(&answer);
  58
  59         return 0;
  60 }
  61
  62 /*
  63  * Send a "flush" command to the `git-fsmonitor--daemon` (if running)
  64  * and tell it to flush its cache.
  65  *
  66  * This feature is primarily used by the test suite to simulate a loss of
  67  * sync with the filesystem where we miss kernel events.
  68  */
  69 static int do_send_flush(void)
  70 {
  71         struct strbuf answer = STRBUF_INIT;
  72         int ret;
  73
  74         ret = fsmonitor_ipc__send_command("flush", &answer);
  75         if (ret)
  76                 return ret;
  77
  78         write_in_full(1, answer.buf, answer.len);
  79         strbuf_release(&answer);
  80
  81         return 0;
  82 }
  83
  84 struct hammer_thread_data
  85 {
  86         pthread_t pthread_id;
  87         int thread_nr;
  88
  89         int nr_requests;
  90         const char *token;
  91
  92         int sum_successful;
  93         int sum_errors;
  94 };
  95
  96 static void *hammer_thread_proc(void *_hammer_thread_data)
  97 {
  98         struct hammer_thread_data *data = _hammer_thread_data;
  99         struct strbuf answer = STRBUF_INIT;
 100         int k;
 101         int ret;
 102
 103         trace2_thread_start("hammer");
 104
 105         for (k = 0; k < data->nr_requests; k++) {
 106                 strbuf_reset(&answer);
 107
 108                 ret = fsmonitor_ipc__send_query(data->token, &answer);
 109                 if (ret < 0)
 110                         data->sum_errors++;
 111                 else
 112                         data->sum_successful++;
 113         }
 114
 115         strbuf_release(&answer);
 116         trace2_thread_exit();
 117         return NULL;
 118 }
 119
 120 /*
 121  * Start a pool of client threads that will each send a series of
 122  * commands to the daemon.
 123  *
 124  * The goal is to overload the daemon with a sustained series of
 125  * concurrent requests.
 126  */
 127 static int do_hammer(const char *token, int nr_threads, int nr_requests)
 128 {
 129         struct hammer_thread_data *data = NULL;
 130         int k;
 131         int sum_join_errors = 0;
 132         int sum_commands = 0;
 133         int sum_errors = 0;
 134
 135         if (!token || !*token)
 136                 token = get_token_from_index();
 137         if (nr_threads < 1)
 138                 nr_threads = 1;
 139         if (nr_requests < 1)
 140                 nr_requests = 1;
 141
 142         CALLOC_ARRAY(data, nr_threads);
 143
 144         for (k = 0; k < nr_threads; k++) {
 145                 struct hammer_thread_data *p = &data[k];
 146                 p->thread_nr = k;
 147                 p->nr_requests = nr_requests;
 148                 p->token = token;
 149
 150                 if (pthread_create(&p->pthread_id, NULL, hammer_thread_proc, p)) {
 151                         warning("failed to create thread[%d] skipping remainder", k);
 152                         nr_threads = k;
 153                         break;
 154                 }
 155         }
 156
 157         for (k = 0; k < nr_threads; k++) {
 158                 struct hammer_thread_data *p = &data[k];
 159
 160                 if (pthread_join(p->pthread_id, NULL))
 161                         sum_join_errors++;
 162                 sum_commands += p->sum_successful;
 163                 sum_errors += p->sum_errors;
 164         }
 165
 166         fprintf(stderr, "HAMMER: [threads %d][requests %d] [ok %d][err %d][join %d]\n",
 167                 nr_threads, nr_requests, sum_commands, sum_errors, sum_join_errors);
 168
 169         free(data);
 170
 171         /*
 172          * Return an error if any of the _send_query requests failed.
 173          * We don't care about thread create/join errors.
 174          */
 175         return sum_errors > 0;
 176 }
 177
 178 int cmd__fsmonitor_client(int argc, const char **argv)
 179 {
 180         const char *subcmd;
 181         const char *token = NULL;
 182         int nr_threads = 1;
 183         int nr_requests = 1;
 184
 185         const char * const fsmonitor_client_usage[] = {
 186                 "test-tool fsmonitor-client query [<token>]",
 187                 "test-tool fsmonitor-client flush",
 188                 "test-tool fsmonitor-client hammer [<token>] [<threads>] [<requests>]",
 189                 NULL,
 190         };
 191
 192         struct option options[] = {
 193                 OPT_STRING(0, "token", &token, "token",
 194                            "command token to send to the server"),
 195
 196                 OPT_INTEGER(0, "threads", &nr_threads, "number of client threads"),
 197                 OPT_INTEGER(0, "requests", &nr_requests, "number of requests per thread"),
 198
 199                 OPT_END()
 200         };
 201
 202         argc = parse_options(argc, argv, NULL, options, fsmonitor_client_usage, 0);
 203
 204         if (argc != 1)
 205                 usage_with_options(fsmonitor_client_usage, options);
 206
 207         subcmd = argv[0];
 208
 209         setup_git_directory();
 210
 211         if (!strcmp(subcmd, "query"))
 212                 return !!do_send_query(token);
 213
 214         if (!strcmp(subcmd, "flush"))
 215                 return !!do_send_flush();
 216
 217         if (!strcmp(subcmd, "hammer"))
 218                 return !!do_hammer(token, nr_threads, nr_requests);
 219
 220         die("Unhandled subcommand: '%s'", subcmd);
 221 }
 222 #endif