X-Git-Url: https://git.saurik.com/redis.git/blobdiff_plain/f4f56e1dfba6c8b9b0654f332420fc2e4933fda3..7fc98533392f455974d546c88bd4d41c85e6fe6d:/redis-cli.c diff --git a/redis-cli.c b/redis-cli.c index e977368b..ce8dbde8 100644 --- a/redis-cli.c +++ b/redis-cli.c @@ -1,6 +1,6 @@ /* Redis CLI (command line interface) * - * Copyright (c) 2006-2009, Salvatore Sanfilippo + * Copyright (c) 2009-2010, Salvatore Sanfilippo * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -34,20 +34,31 @@ #include #include #include +#include #include "anet.h" #include "sds.h" #include "adlist.h" #include "zmalloc.h" +#include "linenoise.h" #define REDIS_CMD_INLINE 1 #define REDIS_CMD_BULK 2 +#define REDIS_CMD_MULTIBULK 4 #define REDIS_NOTUSED(V) ((void) V) static struct config { char *hostip; int hostport; + long repeat; + int dbnum; + int interactive; + int shutdown; + int monitor_mode; + int pubsub_mode; + int raw_output; + char *auth; } config; struct redisCommand { @@ -56,63 +67,119 @@ struct redisCommand { int flags; }; +#define CMDFLAG_NONE 0 +#define CMDFLAG_RAWOUTPUT 1 + static struct redisCommand cmdTable[] = { - {"get",2,REDIS_CMD_INLINE}, - {"set",3,REDIS_CMD_BULK}, - {"setnx",3,REDIS_CMD_BULK}, - {"del",-2,REDIS_CMD_INLINE}, - {"exists",2,REDIS_CMD_INLINE}, - {"incr",2,REDIS_CMD_INLINE}, - {"decr",2,REDIS_CMD_INLINE}, - {"rpush",3,REDIS_CMD_BULK}, - {"lpush",3,REDIS_CMD_BULK}, - {"rpop",2,REDIS_CMD_INLINE}, - {"lpop",2,REDIS_CMD_INLINE}, - {"llen",2,REDIS_CMD_INLINE}, - {"lindex",3,REDIS_CMD_INLINE}, - {"lset",4,REDIS_CMD_BULK}, - {"lrange",4,REDIS_CMD_INLINE}, - {"ltrim",4,REDIS_CMD_INLINE}, - {"lrem",4,REDIS_CMD_BULK}, - {"sadd",3,REDIS_CMD_BULK}, - {"srem",3,REDIS_CMD_BULK}, - {"smove",4,REDIS_CMD_BULK}, - {"sismember",3,REDIS_CMD_BULK}, - {"scard",2,REDIS_CMD_INLINE}, - {"sinter",-2,REDIS_CMD_INLINE}, - {"sinterstore",-3,REDIS_CMD_INLINE}, - {"sunion",-2,REDIS_CMD_INLINE}, - {"sunionstore",-3,REDIS_CMD_INLINE}, - {"sdiff",-2,REDIS_CMD_INLINE}, - {"sdiffstore",-3,REDIS_CMD_INLINE}, - {"smembers",2,REDIS_CMD_INLINE}, - {"incrby",3,REDIS_CMD_INLINE}, - {"decrby",3,REDIS_CMD_INLINE}, - {"getset",3,REDIS_CMD_BULK}, - {"randomkey",1,REDIS_CMD_INLINE}, - {"select",2,REDIS_CMD_INLINE}, - {"move",3,REDIS_CMD_INLINE}, - {"rename",3,REDIS_CMD_INLINE}, - {"renamenx",3,REDIS_CMD_INLINE}, - {"keys",2,REDIS_CMD_INLINE}, - {"dbsize",1,REDIS_CMD_INLINE}, - {"ping",1,REDIS_CMD_INLINE}, - {"echo",2,REDIS_CMD_BULK}, - {"save",1,REDIS_CMD_INLINE}, - {"bgsave",1,REDIS_CMD_INLINE}, - {"shutdown",1,REDIS_CMD_INLINE}, - {"lastsave",1,REDIS_CMD_INLINE}, - {"type",2,REDIS_CMD_INLINE}, - {"flushdb",1,REDIS_CMD_INLINE}, - {"flushall",1,REDIS_CMD_INLINE}, - {"sort",-2,REDIS_CMD_INLINE}, - {"info",1,REDIS_CMD_INLINE}, - {"mget",-2,REDIS_CMD_INLINE}, - {"expire",3,REDIS_CMD_INLINE}, - {NULL,0,0} + {"auth",2,CMDFLAG_NONE}, + {"get",2,CMDFLAG_NONE}, + {"set",3,CMDFLAG_NONE}, + {"setnx",3,CMDFLAG_NONE}, + {"setex",4,CMDFLAG_NONE}, + {"append",3,CMDFLAG_NONE}, + {"substr",4,CMDFLAG_NONE}, + {"del",-2,CMDFLAG_NONE}, + {"exists",2,CMDFLAG_NONE}, + {"incr",2,CMDFLAG_NONE}, + {"decr",2,CMDFLAG_NONE}, + {"rpush",3,CMDFLAG_NONE}, + {"lpush",3,CMDFLAG_NONE}, + {"rpop",2,CMDFLAG_NONE}, + {"lpop",2,CMDFLAG_NONE}, + {"brpop",-3,CMDFLAG_NONE}, + {"blpop",-3,CMDFLAG_NONE}, + {"llen",2,CMDFLAG_NONE}, + {"lindex",3,CMDFLAG_NONE}, + {"lset",4,CMDFLAG_NONE}, + {"lrange",4,CMDFLAG_NONE}, + {"ltrim",4,CMDFLAG_NONE}, + {"lrem",4,CMDFLAG_NONE}, + {"rpoplpush",3,CMDFLAG_NONE}, + {"sadd",3,CMDFLAG_NONE}, + {"srem",3,CMDFLAG_NONE}, + {"smove",4,CMDFLAG_NONE}, + {"sismember",3,CMDFLAG_NONE}, + {"scard",2,CMDFLAG_NONE}, + {"spop",2,CMDFLAG_NONE}, + {"srandmember",2,CMDFLAG_NONE}, + {"sinter",-2,CMDFLAG_NONE}, + {"sinterstore",-3,CMDFLAG_NONE}, + {"sunion",-2,CMDFLAG_NONE}, + {"sunionstore",-3,CMDFLAG_NONE}, + {"sdiff",-2,CMDFLAG_NONE}, + {"sdiffstore",-3,CMDFLAG_NONE}, + {"smembers",2,CMDFLAG_NONE}, + {"zadd",4,CMDFLAG_NONE}, + {"zincrby",4,CMDFLAG_NONE}, + {"zrem",3,CMDFLAG_NONE}, + {"zremrangebyscore",4,CMDFLAG_NONE}, + {"zunion",-4,CMDFLAG_NONE}, + {"zinter",-4,CMDFLAG_NONE}, + {"zrange",-4,CMDFLAG_NONE}, + {"zrank",3,CMDFLAG_NONE}, + {"zrevrank",3,CMDFLAG_NONE}, + {"zrangebyscore",-4,CMDFLAG_NONE}, + {"zcount",4,CMDFLAG_NONE}, + {"zrevrange",-4,CMDFLAG_NONE}, + {"zcard",2,CMDFLAG_NONE}, + {"zscore",3,CMDFLAG_NONE}, + {"incrby",3,CMDFLAG_NONE}, + {"decrby",3,CMDFLAG_NONE}, + {"getset",3,CMDFLAG_NONE}, + {"randomkey",1,CMDFLAG_NONE}, + {"select",2,CMDFLAG_NONE}, + {"move",3,CMDFLAG_NONE}, + {"rename",3,CMDFLAG_NONE}, + {"renamenx",3,CMDFLAG_NONE}, + {"keys",2,CMDFLAG_NONE}, + {"dbsize",1,CMDFLAG_NONE}, + {"ping",1,CMDFLAG_NONE}, + {"echo",2,CMDFLAG_NONE}, + {"save",1,CMDFLAG_NONE}, + {"bgsave",1,CMDFLAG_NONE}, + {"rewriteaof",1,CMDFLAG_NONE}, + {"bgrewriteaof",1,CMDFLAG_NONE}, + {"shutdown",1,CMDFLAG_NONE}, + {"lastsave",1,CMDFLAG_NONE}, + {"type",2,CMDFLAG_NONE}, + {"flushdb",1,CMDFLAG_NONE}, + {"flushall",1,CMDFLAG_NONE}, + {"sort",-2,CMDFLAG_NONE}, + {"info",1,CMDFLAG_RAWOUTPUT}, + {"mget",-2,CMDFLAG_NONE}, + {"expire",3,CMDFLAG_NONE}, + {"expireat",3,CMDFLAG_NONE}, + {"ttl",2,CMDFLAG_NONE}, + {"slaveof",3,CMDFLAG_NONE}, + {"debug",-2,CMDFLAG_NONE}, + {"mset",-3,CMDFLAG_NONE}, + {"msetnx",-3,CMDFLAG_NONE}, + {"monitor",1,CMDFLAG_NONE}, + {"multi",1,CMDFLAG_NONE}, + {"exec",1,CMDFLAG_NONE}, + {"discard",1,CMDFLAG_NONE}, + {"hset",4,CMDFLAG_NONE}, + {"hget",3,CMDFLAG_NONE}, + {"hmset",-4,CMDFLAG_NONE}, + {"hmget",-3,CMDFLAG_NONE}, + {"hincrby",4,CMDFLAG_NONE}, + {"hdel",3,CMDFLAG_NONE}, + {"hlen",2,CMDFLAG_NONE}, + {"hkeys",2,CMDFLAG_NONE}, + {"hvals",2,CMDFLAG_NONE}, + {"hgetall",2,CMDFLAG_NONE}, + {"hexists",3,CMDFLAG_NONE}, + {"config",-2,CMDFLAG_NONE}, + {"subscribe",-2,CMDFLAG_NONE}, + {"unsubscribe",-1,CMDFLAG_NONE}, + {"psubscribe",-2,CMDFLAG_NONE}, + {"punsubscribe",-1,CMDFLAG_NONE}, + {"publish",3,CMDFLAG_NONE}, + {NULL,0,CMDFLAG_NONE} }; static int cliReadReply(int fd); +static void usage(); static struct redisCommand *lookupCommand(char *name) { int j = 0; @@ -125,14 +192,16 @@ static struct redisCommand *lookupCommand(char *name) { static int cliConnect(void) { char err[ANET_ERR_LEN]; - int fd; + static int fd = ANET_ERR; - fd = anetTcpConnect(err,config.hostip,config.hostport); if (fd == ANET_ERR) { - fprintf(stderr,"Connect: %s\n",err); - return -1; + fd = anetTcpConnect(err,config.hostip,config.hostport); + if (fd == ANET_ERR) { + fprintf(stderr, "Could not connect to Redis at %s:%d: %s", config.hostip, config.hostport, err); + return -1; + } + anetTcpNoDelay(NULL,fd); } - anetTcpNoDelay(NULL,fd); return fd; } @@ -156,14 +225,41 @@ static sds cliReadLine(int fd) { return sdstrim(line,"\r\n"); } -static int cliReadSingleLineReply(int fd) { +static int cliReadSingleLineReply(int fd, int quiet) { sds reply = cliReadLine(fd); if (reply == NULL) return 1; - printf("%s\n", reply); + if (!quiet) + printf("%s\n", reply); + sdsfree(reply); return 0; } +static void printStringRepr(char *s, int len) { + printf("\""); + while(len--) { + switch(*s) { + case '\\': + case '"': + printf("\\%c",*s); + break; + case '\n': printf("\\n"); break; + case '\r': printf("\\r"); break; + case '\t': printf("\\t"); break; + case '\a': printf("\\a"); break; + case '\b': printf("\\b"); break; + default: + if (isprint(*s)) + printf("%c",*s); + else + printf("\\x%02x",(unsigned char)*s); + break; + } + s++; + } + printf("\"\n"); +} + static int cliReadBulkReply(int fd) { sds replylen = cliReadLine(fd); char *reply, crlf[2]; @@ -173,18 +269,22 @@ static int cliReadBulkReply(int fd) { bulklen = atoi(replylen); if (bulklen == -1) { sdsfree(replylen); - printf("(nil)"); + printf("(nil)\n"); return 0; } reply = zmalloc(bulklen); anetRead(fd,reply,bulklen); anetRead(fd,crlf,2); - if (bulklen && fwrite(reply,bulklen,1,stdout) == 0) { - zfree(reply); - return 1; + if (config.raw_output || !isatty(fileno(stdout))) { + if (bulklen && fwrite(reply,bulklen,1,stdout) == 0) { + zfree(reply); + return 1; + } + } else { + /* If you are producing output for the standard output we want + * a more interesting output with quoted characters and so forth */ + printStringRepr(reply,bulklen); } - if (isatty(fileno(stdout)) && reply[bulklen-1] != '\n') - printf("\n"); zfree(reply); return 0; } @@ -214,15 +314,20 @@ static int cliReadMultiBulkReply(int fd) { static int cliReadReply(int fd) { char type; - if (anetRead(fd,&type,1) <= 0) exit(1); + if (anetRead(fd,&type,1) <= 0) { + if (config.shutdown) return 0; + exit(1); + } switch(type) { case '-': printf("(error) "); - cliReadSingleLineReply(fd); + cliReadSingleLineReply(fd,0); return 1; case '+': + return cliReadSingleLineReply(fd,0); case ':': - return cliReadSingleLineReply(fd); + printf("(integer) "); + return cliReadSingleLineReply(fd,0); case '$': return cliReadBulkReply(fd); case '*': @@ -233,44 +338,86 @@ static int cliReadReply(int fd) { } } -static int cliSendCommand(int argc, char **argv) { +static int selectDb(int fd) { + int retval; + sds cmd; + char type; + + if (config.dbnum == 0) + return 0; + + cmd = sdsempty(); + cmd = sdscatprintf(cmd,"SELECT %d\r\n",config.dbnum); + anetWrite(fd,cmd,sdslen(cmd)); + anetRead(fd,&type,1); + if (type <= 0 || type != '+') return 1; + retval = cliReadSingleLineReply(fd,1); + if (retval) { + return retval; + } + return 0; +} + +static int cliSendCommand(int argc, char **argv, int repeat) { struct redisCommand *rc = lookupCommand(argv[0]); int fd, j, retval = 0; - sds cmd = sdsempty(); + sds cmd; if (!rc) { fprintf(stderr,"Unknown command '%s'\n",argv[0]); return 1; } + config.raw_output = (rc->flags & CMDFLAG_RAWOUTPUT); if ((rc->arity > 0 && argc != rc->arity) || (rc->arity < 0 && argc < -rc->arity)) { fprintf(stderr,"Wrong number of arguments for '%s'\n",rc->name); return 1; } + + if (!strcasecmp(rc->name,"shutdown")) config.shutdown = 1; + if (!strcasecmp(rc->name,"monitor")) config.monitor_mode = 1; + if (!strcasecmp(rc->name,"subscribe") || + !strcasecmp(rc->name,"psubscribe")) config.pubsub_mode = 1; if ((fd = cliConnect()) == -1) return 1; - /* Build the command to send */ - for (j = 0; j < argc; j++) { - if (j != 0) cmd = sdscat(cmd," "); - if (j == argc-1 && rc->flags & REDIS_CMD_BULK) { - cmd = sdscatprintf(cmd,"%d",sdslen(argv[j])); - } else { + /* Select db number */ + retval = selectDb(fd); + if (retval) { + fprintf(stderr,"Error setting DB num\n"); + return 1; + } + + while(repeat--) { + /* Build the command to send */ + cmd = sdscatprintf(sdsempty(),"*%d\r\n",argc); + for (j = 0; j < argc; j++) { + cmd = sdscatprintf(cmd,"$%lu\r\n", + (unsigned long)sdslen(argv[j])); cmd = sdscatlen(cmd,argv[j],sdslen(argv[j])); + cmd = sdscatlen(cmd,"\r\n",2); + } + anetWrite(fd,cmd,sdslen(cmd)); + sdsfree(cmd); + + while (config.monitor_mode) { + cliReadSingleLineReply(fd,0); + } + + if (config.pubsub_mode) { + printf("Reading messages... (press Ctrl-c to quit)\n"); + while (1) { + cliReadReply(fd); + printf("\n"); + } + } + + retval = cliReadReply(fd); + + if (retval) { + return retval; } } - cmd = sdscat(cmd,"\r\n"); - if (rc->flags & REDIS_CMD_BULK) { - cmd = sdscatlen(cmd,argv[argc-1],sdslen(argv[argc-1])); - cmd = sdscat(cmd,"\r\n"); - } - anetWrite(fd,cmd,sdslen(cmd)); - retval = cliReadReply(fd); - if (retval) { - close(fd); - return retval; - } - close(fd); return 0; } @@ -279,7 +426,7 @@ static int parseOptions(int argc, char **argv) { for (i = 1; i < argc; i++) { int lastarg = i==argc-1; - + if (!strcmp(argv[i],"-h") && !lastarg) { char *ip = zmalloc(32); if (anetResolve(NULL,argv[i+1],ip) == ANET_ERR) { @@ -288,9 +435,22 @@ static int parseOptions(int argc, char **argv) { } config.hostip = ip; i++; + } else if (!strcmp(argv[i],"-h") && lastarg) { + usage(); } else if (!strcmp(argv[i],"-p") && !lastarg) { config.hostport = atoi(argv[i+1]); i++; + } else if (!strcmp(argv[i],"-r") && !lastarg) { + config.repeat = strtoll(argv[i+1],NULL,10); + i++; + } else if (!strcmp(argv[i],"-n") && !lastarg) { + config.dbnum = atoi(argv[i+1]); + i++; + } else if (!strcmp(argv[i],"-a") && !lastarg) { + config.auth = argv[i+1]; + i++; + } else if (!strcmp(argv[i],"-i")) { + config.interactive = 1; } else { break; } @@ -315,37 +475,160 @@ static sds readArgFromStdin(void) { return arg; } +static void usage() { + fprintf(stderr, "usage: redis-cli [-h host] [-p port] [-a authpw] [-r repeat_times] [-n db_num] [-i] cmd arg1 arg2 arg3 ... argN\n"); + fprintf(stderr, "usage: echo \"argN\" | redis-cli [-h host] [-a authpw] [-p port] [-r repeat_times] [-n db_num] cmd arg1 arg2 ... arg(N-1)\n"); + fprintf(stderr, "\nIf a pipe from standard input is detected this data is used as last argument.\n\n"); + fprintf(stderr, "example: cat /etc/passwd | redis-cli set my_passwd\n"); + fprintf(stderr, "example: redis-cli get my_passwd\n"); + fprintf(stderr, "example: redis-cli -r 100 lpush mylist x\n"); + fprintf(stderr, "\nRun in interactive mode: redis-cli -i or just don't pass any command\n"); + exit(1); +} + +/* Turn the plain C strings into Sds strings */ +static char **convertToSds(int count, char** args) { + int j; + char **sds = zmalloc(sizeof(char*)*count+1); + + for(j = 0; j < count; j++) + sds[j] = sdsnew(args[j]); + + return sds; +} + +static char **splitArguments(char *line, int *argc) { + char *p = line; + char *current = NULL; + char **vector = NULL; + + *argc = 0; + while(1) { + /* skip blanks */ + while(*p && isspace(*p)) p++; + if (*p) { + /* get a token */ + int inq=0; /* set to 1 if we are in "quotes" */ + int done = 0; + + if (current == NULL) current = sdsempty(); + while(!done) { + if (inq) { + if (*p == '\\' && *(p+1)) { + char c; + + p++; + switch(*p) { + case 'n': c = '\n'; break; + case 'r': c = '\r'; break; + case 't': c = '\t'; break; + case 'b': c = '\b'; break; + case 'a': c = '\a'; break; + default: c = *p; break; + } + current = sdscatlen(current,&c,1); + } else if (*p == '"') { + done = 1; + } else { + current = sdscatlen(current,p,1); + } + } else { + switch(*p) { + case ' ': + case '\n': + case '\r': + case '\t': + case '\0': + done=1; + break; + case '"': + inq=1; + break; + default: + current = sdscatlen(current,p,1); + break; + } + } + if (*p) p++; + } + /* add the token to the vector */ + vector = zrealloc(vector,((*argc)+1)*sizeof(char*)); + vector[*argc] = current; + (*argc)++; + current = NULL; + } else { + return vector; + } + } +} + +#define LINE_BUFLEN 4096 +static void repl() { + int argc, j; + char *line, **argv; + + while((line = linenoise("redis> ")) != NULL) { + if (line[0] != '\0') { + argv = splitArguments(line,&argc); + linenoiseHistoryAdd(line); + if (argc > 0) { + if (strcasecmp(argv[0],"quit") == 0 || + strcasecmp(argv[0],"exit") == 0) + exit(0); + else + cliSendCommand(argc, argv, 1); + } + /* Free the argument vector */ + for (j = 0; j < argc; j++) + sdsfree(argv[j]); + zfree(argv); + } + /* linenoise() returns malloc-ed lines like readline() */ + free(line); + } + exit(0); +} + int main(int argc, char **argv) { - int firstarg, j; + int firstarg; char **argvcopy; + struct redisCommand *rc; config.hostip = "127.0.0.1"; config.hostport = 6379; + config.repeat = 1; + config.dbnum = 0; + config.shutdown = 0; + config.interactive = 0; + config.monitor_mode = 0; + config.pubsub_mode = 0; + config.raw_output = 0; + config.auth = NULL; firstarg = parseOptions(argc,argv); argc -= firstarg; argv += firstarg; - - /* Turn the plain C strings into Sds strings */ - argvcopy = zmalloc(sizeof(char*)*argc+1); - for(j = 0; j < argc; j++) - argvcopy[j] = sdsnew(argv[j]); - - /* Read the last argument from stdandard input */ - if (!isatty(fileno(stdin))) { + + if (config.auth != NULL) { + char *authargv[2]; + + authargv[0] = "AUTH"; + authargv[1] = config.auth; + cliSendCommand(2, convertToSds(2, authargv), 1); + } + + if (argc == 0 || config.interactive == 1) repl(); + + argvcopy = convertToSds(argc, argv); + + /* Read the last argument from stdandard input if needed */ + if ((rc = lookupCommand(argv[0])) != NULL) { + if (rc->arity > 0 && argc == rc->arity-1) { sds lastarg = readArgFromStdin(); argvcopy[argc] = lastarg; argc++; + } } - if (argc < 1) { - fprintf(stderr, "usage: redis-cli [-h host] [-p port] cmd arg1 arg2 arg3 ... argN\n"); - fprintf(stderr, "usage: echo \"argN\" | redis-cli [-h host] [-p port] cmd arg1 arg2 ... arg(N-1)\n"); - fprintf(stderr, "\nIf a pipe from standard input is detected this data is used as last argument.\n\n"); - fprintf(stderr, "example: cat /etc/passwd | redis-cli set my_passwd\n"); - fprintf(stderr, "example: redis-cli get my_passwd\n"); - exit(1); - } - - return cliSendCommand(argc, argvcopy); + return cliSendCommand(argc, argvcopy, config.repeat); }