关键词搜索

源码搜索 ×
×

漫话Redis源码之二十八

发布2021-12-12浏览530次

详情内容

这里主要是一些控制信息，看似复杂，其实还是比较明朗的：

  1. /* Cluster Manager Command Info */
  2. typedef struct clusterManagerCommand {
  3.     char *name;
  4.     int argc;
  5.     char **argv;
  6.     int flags;
  7.     int replicas;
  8.     char *from;
  9.     char *to;
  10.     char **weight;
  11.     int weight_argc;
  12.     char *master_id;
  13.     int slots;
  14.     int timeout;
  15.     int pipeline;
  16.     float threshold;
  17.     char *backup_dir;
  18.     char *from_user;
  19.     char *from_pass;
  20.     int from_askpass;
  21. } clusterManagerCommand;
  22.  
  23. static void createClusterManagerCommand(char *cmdname, int argc, char **argv);
  24.  
  25.  
  26. static redisContext *context;
  27. static struct config {
  28.     char *hostip;
  29.     int hostport;
  30.     char *hostsocket;
  31.     int tls;
  32.     cliSSLconfig sslconfig;
  33.     long repeat;
  34.     long interval;
  35.     int dbnum; /* db num currently selected */
  36.     int input_dbnum; /* db num user input */
  37.     int interactive;
  38.     int shutdown;
  39.     int monitor_mode;
  40.     int pubsub_mode;
  41.     int latency_mode;
  42.     int latency_dist_mode;
  43.     int latency_history;
  44.     int lru_test_mode;
  45.     long long lru_test_sample_size;
  46.     int cluster_mode;
  47.     int cluster_reissue_command;
  48.     int cluster_send_asking;
  49.     int slave_mode;
  50.     int pipe_mode;
  51.     int pipe_timeout;
  52.     int getrdb_mode;
  53.     int stat_mode;
  54.     int scan_mode;
  55.     int intrinsic_latency_mode;
  56.     int intrinsic_latency_duration;
  57.     sds pattern;
  58.     char *rdb_filename;
  59.     int bigkeys;
  60.     int memkeys;
  61.     unsigned memkeys_samples;
  62.     int hotkeys;
  63.     int stdinarg; /* get last arg from stdin. (-x option) */
  64.     char *auth;
  65.     int askpass;
  66.     char *user;
  67.     int quoted_input;   /* Force input args to be treated as quoted strings */
  68.     int output; /* output mode, see OUTPUT_* defines */
  69.     int push_output; /* Should we display spontaneous PUSH replies */
  70.     sds mb_delim;
  71.     sds cmd_delim;
  72.     char prompt[128];
  73.     char *eval;
  74.     int eval_ldb;
  75.     int eval_ldb_sync;  /* Ask for synchronous mode of the Lua debugger. */
  76.     int eval_ldb_end;   /* Lua debugging session ended. */
  77.     int enable_ldb_on_eval; /* Handle manual SCRIPT DEBUG + EVAL commands. */
  78.     int last_cmd_type;
  79.     int verbose;
  80.     int set_errcode;
  81.     clusterManagerCommand cluster_manager_command;
  82.     int no_auth_warning;
  83.     int resp3;
  84.     int in_multi;
  85.     int pre_multi_dbnum;
  86. } config;
  87.  
  88. /* User preferences. */
  89. static struct pref {
  90.     int hints;
  91. } pref;
  92.  
  93. static volatile sig_atomic_t force_cancel_loop = 0;
  94. static void usage(void);
  95. static void slaveMode(void);
  96. char *redisGitSHA1(void);
  97. char *redisGitDirty(void);
  98. static int cliConnect(int force);
  99.  
  100. static char *getInfoField(char *info, char *field);
  101. static long getLongInfoField(char *info, char *field);
  102.  
  103. /*------------------------------------------------------------------------------
  104.  * Utility functions
  105.  *--------------------------------------------------------------------------- */
  106.  
  107. static void cliPushHandler(void *, void *);
  108.  
  109. uint16_t crc16(const char *buf, int len);
  110.  
  111. static long long ustime(void) {
  112.     struct timeval tv;
  113.     long long ust;
  114.  
  115.     gettimeofday(&tv, NULL);
  116.     ust = ((long long)tv.tv_sec)*1000000;
  117.     ust += tv.tv_usec;
  118.     return ust;
  119. }
  120.  
  121. static long long mstime(void) {
  122.     return ustime()/1000;
  123. }
  124.  
  125. static void cliRefreshPrompt(void) {
  126.     if (config.eval_ldb) return;
  127.  
  128.     sds prompt = sdsempty();
  129.     if (config.hostsocket != NULL) {
  130.         prompt = sdscatfmt(prompt,"redis %s",config.hostsocket);
  131.     } else {
  132.         char addr[256];
  133.         anetFormatAddr(addr, sizeof(addr), config.hostip, config.hostport);
  134.         prompt = sdscatlen(prompt,addr,strlen(addr));
  135.     }
  136.  
  137.     /* Add [dbnum] if needed */
  138.     if (config.dbnum != 0)
  139.         prompt = sdscatfmt(prompt,"[%i]",config.dbnum);
  140.  
  141.     /* Add TX if in transaction state*/
  142.     if (config.in_multi)  
  143.         prompt = sdscatlen(prompt,"(TX)",4);
  144.  
  145.     /* Copy the prompt in the static buffer. */
  146.     prompt = sdscatlen(prompt,"> ",2);
  147.     snprintf(config.prompt,sizeof(config.prompt),"%s",prompt);
  148.     sdsfree(prompt);
  149. }
  150.  
  151. /* Return the name of the dotfile for the specified 'dotfilename'.
  152.  * Normally it just concatenates user $HOME to the file specified
  153.  * in 'dotfilename'. However if the environment variable 'envoverride'
  154.  * is set, its value is taken as the path.
  155.  *
  156.  * The function returns NULL (if the file is /dev/null or cannot be
  157.  * obtained for some error), or an SDS string that must be freed by
  158.  * the user. */
  159. static sds getDotfilePath(char *envoverride, char *dotfilename) {
  160.     char *path = NULL;
  161.     sds dotPath = NULL;
  162.  
  163.     /* Check the env for a dotfile override. */
  164.     path = getenv(envoverride);
  165.     if (path != NULL && *path != '\0') {
  166.         if (!strcmp("/dev/null", path)) {
  167.             return NULL;
  168.         }
  169.  
  170.         /* If the env is set, return it. */
  171.         dotPath = sdsnew(path);
  172.     } else {
  173.         char *home = getenv("HOME");
  174.         if (home != NULL && *home != '\0') {
  175.             /* If no override is set use $HOME/<dotfilename>. */
  176.             dotPath = sdscatprintf(sdsempty(), "%s/%s", home, dotfilename);
  177.         }
  178.     }
  179.     return dotPath;
  180. }
  181.  
  182. /* URL-style percent decoding. */
  183. #define isHexChar(c) (isdigit(c) || (c >= 'a' && c <= 'f'))
  184. #define decodeHexChar(c) (isdigit(c) ? c - '0' : c - 'a' + 10)
  185. #define decodeHex(h, l) ((decodeHexChar(h) << 4) + decodeHexChar(l))
  186.  
  187. static sds percentDecode(const char *pe, size_t len) {
  188.     const char *end = pe + len;
  189.     sds ret = sdsempty();
  190.     const char *curr = pe;
  191.  
  192.     while (curr < end) {
  193.         if (*curr == '%') {
  194.             if ((end - curr) < 2) {
  195.                 fprintf(stderr, "Incomplete URI encoding\n");
  196.                 exit(1);
  197.             }
  198.  
  199.             char h = tolower(*(++curr));
  200.             char l = tolower(*(++curr));
  201.             if (!isHexChar(h) || !isHexChar(l)) {
  202.                 fprintf(stderr, "Illegal character in URI encoding\n");
  203.                 exit(1);
  204.             }
  205.             char c = decodeHex(h, l);
  206.             ret = sdscatlen(ret, &c, 1);
  207.             curr++;
  208.         } else {
  209.             ret = sdscatlen(ret, curr++, 1);
  210.         }
  211.     }
  212.  
  213.     return ret;
  214. }
  215.  
  216. /* Parse a URI and extract the server connection information.
  217.  * URI scheme is based on the the provisional specification[1] excluding support
  218.  * for query parameters. Valid URIs are:
  219.  *   scheme:    "redis://"
  220.  *   authority: [[<username> ":"] <password> "@"] [<hostname> [":" <port>]]
  221.  *   path:      ["/" [<db>]]
  222.  *
  223.  *  [1]: https://www.iana.org/assignments/uri-schemes/prov/redis */
  224. static void parseRedisUri(const char *uri) {
  225.  
  226.     const char *scheme = "redis://";
  227.     const char *tlsscheme = "rediss://";
  228.     const char *curr = uri;
  229.     const char *end = uri + strlen(uri);
  230.     const char *userinfo, *username, *port, *host, *path;
  231.  
  232.     /* URI must start with a valid scheme. */
  233.     if (!strncasecmp(tlsscheme, curr, strlen(tlsscheme))) {
  234. #ifdef USE_OPENSSL
  235.         config.tls = 1;
  236.         curr += strlen(tlsscheme);
  237. #else
  238.         fprintf(stderr,"rediss:// is only supported when redis-cli is compiled with OpenSSL\n");
  239.         exit(1);
  240. #endif
  241.     } else if (!strncasecmp(scheme, curr, strlen(scheme))) {
  242.         curr += strlen(scheme);
  243.     } else {
  244.         fprintf(stderr,"Invalid URI scheme\n");
  245.         exit(1);
  246.     }
  247.     if (curr == end) return;
  248.  
  249.     /* Extract user info. */
  250.     if ((userinfo = strchr(curr,'@'))) {
  251.         if ((username = strchr(curr, ':')) && username < userinfo) {
  252.             config.user = percentDecode(curr, username - curr);
  253.             curr = username + 1;
  254.         }
  255.  
  256.         config.auth = percentDecode(curr, userinfo - curr);
  257.         curr = userinfo + 1;
  258.     }
  259.     if (curr == end) return;
  260.  
  261.     /* Extract host and port. */
  262.     path = strchr(curr, '/');
  263.     if (*curr != '/') {
  264.         host = path ? path - 1 : end;
  265.         if ((port = strchr(curr, ':'))) {
  266.             config.hostport = atoi(port + 1);
  267.             host = port - 1;
  268.         }
  269.         config.hostip = sdsnewlen(curr, host - curr + 1);
  270.     }
  271.     curr = path ? path + 1 : end;
  272.     if (curr == end) return;
  273.  
  274.     /* Extract database number. */
  275.     config.input_dbnum = atoi(curr);
  276. }
  277.  
  278. static uint64_t dictSdsHash(const void *key) {
  279.     return dictGenHashFunction((unsigned char*)key, sdslen((char*)key));
  280. }
  281.  
  282. static int dictSdsKeyCompare(void *privdata, const void *key1,
  283.         const void *key2)
  284. {
  285.     int l1,l2;
  286.     DICT_NOTUSED(privdata);
  287.  
  288.     l1 = sdslen((sds)key1);
  289.     l2 = sdslen((sds)key2);
  290.     if (l1 != l2) return 0;
  291.     return memcmp(key1, key2, l1) == 0;
  292. }
  293.  
  294. static void dictSdsDestructor(void *privdata, void *val)
  295. {
  296.     DICT_NOTUSED(privdata);
  297.     sdsfree(val);
  298. }
  299.  
  300. void dictListDestructor(void *privdata, void *val)
  301. {
  302.     DICT_NOTUSED(privdata);
  303.     listRelease((list*)val);
  304. }
  305.  
  306. /* _serverAssert is needed by dict */
  307. void _serverAssert(const char *estr, const char *file, int line) {
  308.     fprintf(stderr, "=== ASSERTION FAILED ===");
  309.     fprintf(stderr, "==> %s:%d '%s' is not true",file,line,estr);
  310.     *((char*)-1) = 'x';
  311. }

相关技术文章

最新源码

下载排行榜
点击QQ咨询
开通会员
返回顶部
×
微信扫码支付 元
微信扫码支付
确定支付下载
请使用微信描二维码支付
×

提示信息

×

选择支付方式

  • 微信支付
  • 支付宝付款
确定支付下载