这份代码是redis的client接口，其和server端的交互使用了deps目录下的hiredis c库，同时，在这部分代码中，应用了linenoise库完成类似history命令查询、自动补全等终端控制功能。
1 #include "fmacros.h" //用于mac下的兼容性处理
2 #include "version.h" //版本信息头文件，当前版本是2.4.10
3
4 #include <stdio.h>
5 #include <string.h>
6 #include <stdlib.h>
7 #include <unistd.h>
8 #include <ctype.h>
9 #include <errno.h>
10 #include <sys/stat.h>
11 #include <sys/time.h>
12 #include <assert.h>
13
14 #include "hiredis.h" //redis 客户端库的头文件
15 #include "sds.h"
16 #include "zmalloc.h"
17 #include "linenoise.h" //终端控制库的头文件
18 #include "help.h" //当前所有的命令文件汇总，用于tab自动补全功能的源数据
/* help entry的结构如下：
struct commandHelp {
20 char *name; //命令名字
21 char *params; //参数格式
22 char *summary; //简单的解释信息
23 int group; //命令类型（当前版本共分10种不同类型的命令）
24 char *since; //从哪个版本开始支持此命令
25 } */
19
20 #define REDIS_NOTUSED(V) ((void) V)
21
22 static redisContext *context; //维护client和server端的连接信息，包括文件描述符，错误信息等，参见deps/hiredis/hiredis.h
23 static struct config {
24 char *hostip;
25 int hostport;
26 char *hostsocket;
27 long repeat; //命令重复执行次数
28 long interval; //命令重复执行间隔
29 int dbnum; // db no.
30 int interactive; //交互模式 or 命令模式
31 int shutdown;
32 int monitor_mode; //监控模式
33 int pubsub_mode; //pub sub模式
34 int latency_mode; //该模式测试cli到server执行ping命令的时间间隔（应用层ping）
35 int stdinarg; /* get last arg from stdin. (-x option) */
36 char *auth; //需要鉴权时的密码信息
37 int raw_output; /* output mode per command */ //选择该模式，将不会添加类似（interger），参见http://blog.sina.com.cn/s/blog_6262a50e0100zw83.html
38 sds mb_delim;
39 char prompt[128];
40 } config;
41
42 static void usage();
43 char *redisGitSHA1(void);
44 char *redisGitDirty(void);
45
46 /*------------------------------------------------------------------------------
47 * Utility functions
48 *--------------------------------------------------------------------------- */
49
50 static long long mstime(void) {
51 struct timeval tv;
52 long long mst;
53
54 gettimeofday(&tv, NULL);
55 mst = ((long)tv.tv_sec)*1000;
56 mst += tv.tv_usec/1000;
57 return mst;
58 }
59
60 static void cliRefreshPrompt(void) {
61 int len;
62
63 if (config.hostsocket != NULL)
64 len = snprintf(config.prompt,sizeof(config.prompt),"redis %s",
65 config.hostsocket);
66 else
67 len = snprintf(config.prompt,sizeof(config.prompt),"redis %s:%d",
68 config.hostip, config.hostport);
69 /* Add [dbnum] if needed */
70 if (config.dbnum != 0)
71 len += snprintf(config.prompt+len,sizeof(config.prompt)-len,"[%d]",
72 config.dbnum);
73 snprintf(config.prompt+len,sizeof(config.prompt)-len,"> ");
74 }
75
76 /*------------------------------------------------------------------------------
77 * Help functions
78 *--------------------------------------------------------------------------- */
79
80 #define CLI_HELP_COMMAND 1
81 #define CLI_HELP_GROUP 2
82
83 typedef struct {
84 int type;
85 int argc;
86 sds *argv;
87 sds full;
88
89 /* Only used for help on commands */
90 struct commandHelp *org;
91 } helpEntry;
92
93 static helpEntry *helpEntries;
94 static int helpEntriesLen;
95
96 static sds cliVersion() {
97 sds version;
98 version = sdscatprintf(sdsempty(), "%s", REDIS_VERSION);
99
100 /* Add git commit and working tree status when available */
101 if (strtoll(redisGitSHA1(),NULL,16)) {
102 version = sdscatprintf(version, " (git:%s", redisGitSHA1());
103 if (strtoll(redisGitDirty(),NULL,10))
104 version = sdscatprintf(version, "-dirty");
105 version = sdscat(version, ")");
106 }
107 return version;
108 }
109
110 static void cliInitHelp() {
111 int commandslen = sizeof(commandHelp)/sizeof(struct commandHelp);
112 int groupslen = sizeof(commandGroups)/sizeof(char*);
113 int i, len, pos = 0;
114 helpEntry tmp;
115
116 helpEntriesLen = len = commandslen+groupslen;
117 helpEntries = malloc(sizeof(helpEntry)*len);
118
119 for (i = 0; i < groupslen; i++) {
120 tmp.argc = 1;
121 tmp.argv = malloc(sizeof(sds));
122 tmp.argv[0] = sdscatprintf(sdsempty(),"@%s",commandGroups[i]);
123 tmp.full = tmp.argv[0];
124 tmp.type = CLI_HELP_GROUP;
125 tmp.org = NULL;
126 helpEntries[pos++] = tmp;
127 }
128
129 for (i = 0; i < commandslen; i++) {
130 tmp.argv = sdssplitargs(commandHelp[i].name,&tmp.argc);
131 tmp.full = sdsnew(commandHelp[i].name);
132 tmp.type = CLI_HELP_COMMAND;
133 tmp.org = &commandHelp[i];
134 helpEntries[pos++] = tmp;
135 }
136 }
137
138 /* Output command help to stdout. */
139 static void cliOutputCommandHelp(struct commandHelp *help, int group) {
140 printf("\r\n \x1b[1m%s\x1b[0m \x1b[90m%s\x1b[0m\r\n", help->name, help->params);
141 printf(" \x1b[33msummary:\x1b[0m %s\r\n", help->summary);
142 printf(" \x1b[33msince:\x1b[0m %s\r\n", help->since);
143 if (group) {
144 printf(" \x1b[33mgroup:\x1b[0m %s\r\n", commandGroups[help->group]);
145 }
146 }
147
148 /* Print generic help. */
149 static void cliOutputGenericHelp() {
150 sds version = cliVersion();
151 printf(
152 "redis-cli %s\r\n"
153 "Type: \"help @<group>\" to get a list of commands in <group>\r\n"
154 " \"help <command>\" for help on <command>\r\n"
155 " \"help <tab>\" to get a list of possible help topics\r\n"
156 " \"quit\" to exit\r\n",
157 version
158 );
159 sdsfree(version);
160 }
161
162 /* Output all command help, filtering by group or command name. */
163 static void cliOutputHelp(int argc, char **argv) {
164 int i, j, len;
165 int group = -1;
166 helpEntry *entry;
167 struct commandHelp *help;
168
169 if (argc == 0) {
170 cliOutputGenericHelp();
171 return;
172 } else if (argc > 0 && argv[0][0] == '@') {
173 len = sizeof(commandGroups)/sizeof(char*);
174 for (i = 0; i < len; i++) {
175 if (strcasecmp(argv[0]+1,commandGroups[i]) == 0) {
176 group = i;
177 break;
178 }
179 }
180 }
181
182 assert(argc > 0);
183 for (i = 0; i < helpEntriesLen; i++) {
184 entry = &helpEntries[i];
185 if (entry->type != CLI_HELP_COMMAND) continue;
186
187 help = entry->org;
188 if (group == -1) {
189 /* Compare all arguments */
190 if (argc == entry->argc) {
191 for (j = 0; j < argc; j++) {
192 if (strcasecmp(argv[j],entry->argv[j]) != 0) break;
193 }
194 if (j == argc) {
195 cliOutputCommandHelp(help,1);
196 }
197 }
198 } else {
199 if (group == help->group) {
200 cliOutputCommandHelp(help,0);
201 }
202 }
203 }
204 printf("\r\n");
205 }
206
207 static void completionCallback(const char *buf, linenoiseCompletions *lc) {
208 size_t startpos = 0;
209 int mask;
210 int i;
211 size_t matchlen;
212 sds tmp;
213
214 if (strncasecmp(buf,"help ",5) == 0) {
215 startpos = 5;
216 while (isspace(buf[startpos])) startpos++;
217 mask = CLI_HELP_COMMAND | CLI_HELP_GROUP;
218 } else {
219 mask = CLI_HELP_COMMAND;
220 }
221
222 for (i = 0; i < helpEntriesLen; i++) {
223 if (!(helpEntries[i].type & mask)) continue;
224
225 matchlen = strlen(buf+startpos);
226 if (strncasecmp(buf+startpos,helpEntries[i].full,matchlen) == 0) {
227 tmp = sdsnewlen(buf,startpos);
228 tmp = sdscat(tmp,helpEntries[i].full);
229 linenoiseAddCompletion(lc,tmp);
230 sdsfree(tmp);
231 }
232 }
233 }
234
235 /*------------------------------------------------------------------------------
236 * Networking / parsing
237 *--------------------------------------------------------------------------- */
238
239 /* Send AUTH command to the server */
240 static int cliAuth() {
241 redisReply *reply;
242 if (config.auth == NULL) return REDIS_OK;
243
244 reply = redisCommand(context,"AUTH %s",config.auth);
245 if (reply != NULL) {
246 freeReplyObject(reply);
247 return REDIS_OK;
248 }
249 return REDIS_ERR;
250 }
251
252 /* Send SELECT dbnum to the server */
253 static int cliSelect() {
254 redisReply *reply;
255 if (config.dbnum == 0) return REDIS_OK;
256
257 reply = redisCommand(context,"SELECT %d",config.dbnum);
258 if (reply != NULL) {
259 freeReplyObject(reply);
260 return REDIS_OK;
261 }
262 return REDIS_ERR;
263 }
264
265 /* Connect to the client. If force is not zero the connection is performed
266 * even if there is already a connected socket. */
267 static int cliConnect(int force) {
268 if (context == NULL || force) {
269 if (context != NULL)
270 redisFree(context);
271
272 if (config.hostsocket == NULL) {
273 context = redisConnect(config.hostip,config.hostport);
274 } else {
275 context = redisConnectUnix(config.hostsocket);
276 }
277
278 if (context->err) {
279 fprintf(stderr,"Could not connect to Redis at ");
280 if (config.hostsocket == NULL)
281 fprintf(stderr,"%s:%d: %s\n",config.hostip,config.hostport,context->errstr);
282 else
283 fprintf(stderr,"%s: %s\n",config.hostsocket,context->errstr);
284 redisFree(context);
285 context = NULL;
286 return REDIS_ERR;
287 }
288
289 /* Do AUTH and select the right DB. */
290 if (cliAuth() != REDIS_OK)
291 return REDIS_ERR;
292 if (cliSelect() != REDIS_OK)
293 return REDIS_ERR;
294 }
295 return REDIS_OK;
296 }
297
298 static void cliPrintContextError() {
299 if (context == NULL) return;
300 fprintf(stderr,"Error: %s\n",context->errstr);
301 }
302
303 static sds cliFormatReplyTTY(redisReply *r, char *prefix) {
304 sds out = sdsempty();
305 switch (r->type) {
306 case REDIS_REPLY_ERROR:
307 out = sdscatprintf(out,"(error) %s\n", r->str);
308 break;
309 case REDIS_REPLY_STATUS:
310 out = sdscat(out,r->str);
311 out = sdscat(out,"\n");
312 break;
313 case REDIS_REPLY_INTEGER:
314 out = sdscatprintf(out,"(integer) %lld\n",r->integer);
315 break;
316 case REDIS_REPLY_STRING:
317 /* If you are producing output for the standard output we want
318 * a more interesting output with quoted characters and so forth */
319 out = sdscatrepr(out,r->str,r->len);
320 out = sdscat(out,"\n");
321 break;
322 case REDIS_REPLY_NIL:
323 out = sdscat(out,"(nil)\n");
324 break;
325 case REDIS_REPLY_ARRAY:
326 if (r->elements == 0) {
327 out = sdscat(out,"(empty list or set)\n");
328 } else {
329 unsigned int i, idxlen = 0;
330 char _prefixlen[16];
331 char _prefixfmt[16];
332 sds _prefix;
333 sds tmp;
334
335 /* Calculate chars needed to represent the largest index */
336 i = r->elements;
337 do {
338 idxlen++;
339 i /= 10;
340 } while(i);
341
342 /* Prefix for nested multi bulks should grow with idxlen+2 spaces */
343 memset(_prefixlen,' ',idxlen+2);
344 _prefixlen[idxlen+2] = '\0';
345 _prefix = sdscat(sdsnew(prefix),_prefixlen);
346
347 /* Setup prefix format for every entry */
348 snprintf(_prefixfmt,sizeof(_prefixfmt),"%%s%%%dd) ",idxlen);
349
350 for (i = 0; i < r->elements; i++) {
351 /* Don't use the prefix for the first element, as the parent
352 * caller already prepended the index number. */
353 out = sdscatprintf(out,_prefixfmt,i == 0 ? "" : prefix,i+1);
354
355 /* Format the multi bulk entry */
356 tmp = cliFormatReplyTTY(r->element[i],_prefix);
357 out = sdscatlen(out,tmp,sdslen(tmp));
358 sdsfree(tmp);
359 }
360 sdsfree(_prefix);
361 }
362 break;
363 default:
364 fprintf(stderr,"Unknown reply type: %d\n", r->type);
365 exit(1);
366 }
367 return out;
368 }
369
370 static sds cliFormatReplyRaw(redisReply *r) {
371 sds out = sdsempty(), tmp;
372 size_t i;
373
374 switch (r->type) {
375 case REDIS_REPLY_NIL:
376 /* Nothing... */
377 break;
378 case REDIS_REPLY_ERROR:
379 out = sdscatlen(out,r->str,r->len);
380 out = sdscatlen(out,"\n",1);
381 break;
382 case REDIS_REPLY_STATUS:
383 case REDIS_REPLY_STRING:
384 out = sdscatlen(out,r->str,r->len);
385 break;
386 case REDIS_REPLY_INTEGER:
387 out = sdscatprintf(out,"%lld",r->integer);
388 break;
389 case REDIS_REPLY_ARRAY:
390 for (i = 0; i < r->elements; i++) {
391 if (i > 0) out = sdscat(out,config.mb_delim);
392 tmp = cliFormatReplyRaw(r->element[i]);
393 out = sdscatlen(out,tmp,sdslen(tmp));
394 sdsfree(tmp);
395 }
396 break;
397 default:
398 fprintf(stderr,"Unknown reply type: %d\n", r->type);
399 exit(1);
400 }
401 return out;
402 }
403
404 static int cliReadReply(int output_raw_strings) {
405 void *_reply;
406 redisReply *reply;
407 sds out;
408
409 if (redisGetReply(context,&_reply) != REDIS_OK) {
410 if (config.shutdown)
411 return REDIS_OK;
412 if (config.interactive) {
413 /* Filter cases where we should reconnect */
414 if (context->err == REDIS_ERR_IO && errno == ECONNRESET)
415 return REDIS_ERR;
416 if (context->err == REDIS_ERR_EOF)
417 return REDIS_ERR;
418 }
419 cliPrintContextError();
420 exit(1);
421 return REDIS_ERR; /* avoid compiler warning */
422 }
423
424 reply = (redisReply*)_reply;
425 if (output_raw_strings) {
426 out = cliFormatReplyRaw(reply);
427 } else {
428 if (config.raw_output) {
429 out = cliFormatReplyRaw(reply);
430 out = sdscat(out,"\n");
431 } else {
432 out = cliFormatReplyTTY(reply,"");
433 }
434 }
435 fwrite(out,sdslen(out),1,stdout);
436 sdsfree(out);
437 freeReplyObject(reply);
438 return REDIS_OK;
439 }
440
441 static int cliSendCommand(int argc, char **argv, int repeat) {
442 char *command = argv[0];
443 size_t *argvlen;
444 int j, output_raw;
445
446 if (!strcasecmp(command,"help") || !strcasecmp(command,"?")) {
447 cliOutputHelp(--argc, ++argv);
448 return REDIS_OK;
449 }
450
451 if (context == NULL) return REDIS_ERR;
452
453 output_raw = 0;
454 if (!strcasecmp(command,"info") ||
455 (argc == 2 && !strcasecmp(command,"client") &&
456 !strcasecmp(argv[1],"list")))
457
458 {
459 output_raw = 1;
460 }
461
462 if (!strcasecmp(command,"shutdown")) config.shutdown = 1;
463 if (!strcasecmp(command,"monitor")) config.monitor_mode = 1;
464 if (!strcasecmp(command,"subscribe") ||
465 !strcasecmp(command,"psubscribe")) config.pubsub_mode = 1;
466
467 /* Setup argument length */
468 argvlen = malloc(argc*sizeof(size_t));
469 for (j = 0; j < argc; j++)
470 argvlen[j] = sdslen(argv[j]);
471
472 while(repeat--) {
473 redisAppendCommandArgv(context,argc,(const char**)argv,argvlen);
474 while (config.monitor_mode) {
475 if (cliReadReply(output_raw) != REDIS_OK) exit(1);
476 fflush(stdout);
477 }
478
479 if (config.pubsub_mode) {
480 if (!config.raw_output)
481 printf("Reading messages... (press Ctrl-C to quit)\n");
482 while (1) {
483 if (cliReadReply(output_raw) != REDIS_OK) exit(1);
484 }
485 }
486
487 if (cliReadReply(output_raw) != REDIS_OK) {
488 free(argvlen);
489 return REDIS_ERR;
490 } else {
491 /* Store database number when SELECT was successfully executed. */
492 if (!strcasecmp(command,"select") && argc == 2) {
493 config.dbnum = atoi(argv[1]);
494 cliRefreshPrompt();
495 }
496 }
497 if (config.interval) usleep(config.interval);
498 fflush(stdout); /* Make it grep friendly */
499 }
500
501 free(argvlen);
502 return REDIS_OK;
503 }
504
505 /*------------------------------------------------------------------------------
506 * User interface
507 *--------------------------------------------------------------------------- */
508
509 static int parseOptions(int argc, char **argv) {
510 int i;
511
512 for (i = 1; i < argc; i++) {
513 int lastarg = i==argc-1;
514
515 if (!strcmp(argv[i],"-h") && !lastarg) {
516 sdsfree(config.hostip);
517 config.hostip = sdsnew(argv[i+1]);
518 i++;
519 } else if (!strcmp(argv[i],"-h") && lastarg) {
520 usage();
521 } else if (!strcmp(argv[i],"--help")) {
522 usage();
523 } else if (!strcmp(argv[i],"-x")) {
524 config.stdinarg = 1;
525 } else if (!strcmp(argv[i],"-p") && !lastarg) {
526 config.hostport = atoi(argv[i+1]);
527 i++;
528 } else if (!strcmp(argv[i],"-s") && !lastarg) {
529 config.hostsocket = argv[i+1];
530 i++;
531 } else if (!strcmp(argv[i],"-r") && !lastarg) {
532 config.repeat = strtoll(argv[i+1],NULL,10);
533 i++;
534 } else if (!strcmp(argv[i],"-i") && !lastarg) {
535 double seconds = atof(argv[i+1]);
536 config.interval = seconds*1000000;
537 i++;
538 } else if (!strcmp(argv[i],"-n") && !lastarg) {
539 config.dbnum = atoi(argv[i+1]);
540 i++;
541 } else if (!strcmp(argv[i],"-a") && !lastarg) {
542 config.auth = argv[i+1];
543 i++;
544 } else if (!strcmp(argv[i],"--raw")) {
545 config.raw_output = 1;
546 } else if (!strcmp(argv[i],"--latency")) {
547 config.latency_mode = 1;
548 } else if (!strcmp(argv[i],"-d") && !lastarg) {
549 sdsfree(config.mb_delim);
550 config.mb_delim = sdsnew(argv[i+1]);
551 i++;
552 } else if (!strcmp(argv[i],"-v") || !strcmp(argv[i], "--version")) {
553 sds version = cliVersion();
554 printf("redis-cli %s\n", version);
555 sdsfree(version);
556 exit(0);
557 } else {
558 break;
559 }
560 }
561 return i;
562 }
563
564 static sds readArgFromStdin(void) {
565 char buf[1024];
566 sds arg = sdsempty();
567
568 while(1) {
569 int nread = read(fileno(stdin),buf,1024);
570
571 if (nread == 0) break;
572 else if (nread == -1) {
573 perror("Reading from standard input");
574 exit(1);
575 }
576 arg = sdscatlen(arg,buf,nread);
577 }
578 return arg;
579 }
580
581 static void usage() {
582 sds version = cliVersion();
583 fprintf(stderr,
584 "redis-cli %s\n"
585 "\n"
586 "Usage: redis-cli [OPTIONS] [cmd [arg [arg ...]]]\n"
587 " -h <hostname> Server hostname (default: 127.0.0.1)\n"
588 " -p <port> Server port (default: 6379)\n"
589 " -s <socket> Server socket (overrides hostname and port)\n"
590 " -a <password> Password to use when connecting to the server\n"
591 " -r <repeat> Execute specified command N times\n"
592 " -i <interval> When -r is used, waits <interval> seconds per command.\n"
593 " It is possible to specify sub-second times like -i 0.1.\n"
594 " -n <db> Database number\n"
595 " -x Read last argument from STDIN\n"
596 " -d <delimiter> Multi-bulk delimiter in for raw formatting (default: \\n)\n"
597 " --raw Use raw formatting for replies (default when STDOUT is not a tty)\n"
598 " --latency Enter a special mode continuously sampling latency.\n"
599 " --help Output this help and exit\n"
600 " --version Output version and exit\n"
601 "\n"
602 "Examples:\n"
603 " cat /etc/passwd | redis-cli -x set mypasswd\n"
604 " redis-cli get mypasswd\n"
605 " redis-cli -r 100 lpush mylist x\n"
606 " redis-cli -r 100 -i 1 info | grep used_memory_human:\n"
607 "\n"
608 "When no command is given, redis-cli starts in interactive mode.\n"
609 "Type \"help\" in interactive mode for information on available commands.\n"
610 "\n",
611 version);
612 sdsfree(version);
613 exit(1);
614 }
615
616 /* Turn the plain C strings into Sds strings */
617 static char **convertToSds(int count, char** args) {
618 int j;
619 char **sds = zmalloc(sizeof(char*)*count);
620
621 for(j = 0; j < count; j++)
622 sds[j] = sdsnew(args[j]);
623
624 return sds;
625 }
626
627 #define LINE_BUFLEN 4096
628 static void repl() {
629 sds historyfile = NULL;
630 int history = 0;
631 char *line;
632 int argc;
633 sds *argv;
634
635 config.interactive = 1;
636 linenoiseSetCompletionCallback(completionCallback);
637
638 /* Only use history when stdin is a tty. */
639 if (isatty(fileno(stdin))) {
640 history = 1;
641
642 if (getenv("HOME") != NULL) {
643 historyfile = sdscatprintf(sdsempty(),"%s/.rediscli_history",getenv("HOME"));
644 linenoiseHistoryLoad(historyfile);
645 }
646 }
647
648 cliRefreshPrompt();
649 while((line = linenoise(context ? config.prompt : "not connected> ")) != NULL) {
650 if (line[0] != '\0') {
651 argv = sdssplitargs(line,&argc);
652 if (history) linenoiseHistoryAdd(line);
653 if (historyfile) linenoiseHistorySave(historyfile);
654
655 if (argv == NULL) {
656 printf("Invalid argument(s)\n");
657 free(line);
658 continue;
659 } else if (argc > 0) {
660 if (strcasecmp(argv[0],"quit") == 0 ||
661 strcasecmp(argv[0],"exit") == 0)
662 {
663 exit(0);
664 } else if (argc == 3 && !strcasecmp(argv[0],"connect")) {
665 sdsfree(config.hostip);
666 config.hostip = sdsnew(argv[1]);
667 config.hostport = atoi(argv[2]);
668 cliConnect(1);
669 } else if (argc == 1 && !strcasecmp(argv[0],"clear")) {
670 linenoiseClearScreen();
671 } else {
672 long long start_time = mstime(), elapsed;
673 int repeat, skipargs = 0;
674
675 repeat = atoi(argv[0]);
676 if (argc > 1 && repeat) {
677 skipargs = 1;
678 } else {
679 repeat = 1;
680 }
681
682 if (cliSendCommand(argc-skipargs,argv+skipargs,repeat)
683 != REDIS_OK)
684 {
685 cliConnect(1);
686
687 /* If we still cannot send the command print error.
688 * We'll try to reconnect the next time. */
689 if (cliSendCommand(argc-skipargs,argv+skipargs,repeat)
690 != REDIS_OK)
691 cliPrintContextError();
692 }
693 elapsed = mstime()-start_time;
694 if (elapsed >= 500) {
695 printf("(%.2fs)\n",(double)elapsed/1000);
696 }
697 }
698 }
699 /* Free the argument vector */
700 while(argc--) sdsfree(argv[argc]);
701 zfree(argv);
702 }
703 /* linenoise() returns malloc-ed lines like readline() */
704 free(line);
705 }
706 exit(0);
707 }
708
709 static int noninteractive(int argc, char **argv) {
710 int retval = 0;
711 if (config.stdinarg) {
712 argv = zrealloc(argv, (argc+1)*sizeof(char*));
713 argv[argc] = readArgFromStdin();
714 retval = cliSendCommand(argc+1, argv, config.repeat);
715 } else {
716 /* stdin is probably a tty, can be tested with S_ISCHR(s.st_mode) */
717 retval = cliSendCommand(argc, argv, config.repeat);
718 }
719 return retval;
720 }
721
722 static void latencyMode(void) {
723 redisReply *reply;
724 long long start, latency, min, max, tot, count = 0;
725 double avg;
726
727 if (!context) exit(1);
728 while(1) {
729 start = mstime();
730 reply = redisCommand(context,"PING");
731 if (reply == NULL) {
732 fprintf(stderr,"\nI/O error\n");
733 exit(1);
734 }
735 latency = mstime()-start;
736 freeReplyObject(reply);
737 count++;
738 if (count == 1) {
739 min = max = tot = latency;
740 avg = (double) latency;
741 } else {
742 if (latency < min) min = latency;
743 if (latency > max) max = latency;
744 tot += latency;
745 avg = (double) tot/count;
746 }
747 printf("\x1b[0G\x1b[2Kmin: %lld, max: %lld, avg: %.2f (%lld samples)",
748 min, max, avg, count);
749 fflush(stdout);
750 usleep(10000);
751 }
752 }
753
754 int main(int argc, char **argv) {
755 int firstarg;
756
757 config.hostip = sdsnew("127.0.0.1");
758 config.hostport = 6379;
759 config.hostsocket = NULL;
760 config.repeat = 1;
761 config.interval = 0;
762 config.dbnum = 0;
763 config.interactive = 0;
764 config.shutdown = 0;
765 config.monitor_mode = 0;
766 config.pubsub_mode = 0;
767 config.latency_mode = 0;
768 config.stdinarg = 0;
769 config.auth = NULL;
770 config.raw_output = !isatty(fileno(stdout)) && (getenv("FAKETTY") == NULL);
771 config.mb_delim = sdsnew("\n");
772 cliInitHelp();
773
774 firstarg = parseOptions(argc,argv);
775 argc -= firstarg;
776 argv += firstarg;
777
778 /* Start in latency mode if appropriate */
779 if (config.latency_mode) {
780 cliConnect(0);
781 latencyMode();
782 }
783
784 /* Start interactive mode when no command is provided */
785 if (argc == 0) {
786 /* Note that in repl mode we don't abort on connection error.
787 * A new attempt will be performed for every command send. */
788 cliConnect(0);
789 repl();
790 }
791
792 /* Otherwise, we have some arguments to execute */
793 if (cliConnect(0) != REDIS_OK) exit(1);
794 return noninteractive(argc,convertToSds(argc,argv));
795 }