REFACTOR: refactor config file support for server configuration

Author: singsangssong

config_parser.c

@@ -26,9 +26,6 @@
 #include <memcached/config_parser.h>
 #include <memcached/util.h>
 
-static int read_config_file(const char *fname, struct config_item items[],
-                            FILE *error);
-
 /**
  * Copy a string and trim of leading and trailing white space characters.
  * Allow the user to escape out the stop character by putting a backslash before
@@ -224,8 +221,8 @@ int parse_config(const char *str, struct config_item *items, FILE *error) {
    return ret;
 }
 
-static int read_config_file(const char *fname, struct config_item items[],
-                            FILE *error) {
+int read_config_file(const char *fname, struct config_item items[],
+                     FILE *error) {
    FILE *fp = fopen(fname, "r");
    if (fp == NULL) {
       (void)fprintf(error, "Failed to open file: %s\n", fname);

include/memcached/config_parser.h

@@ -77,6 +77,7 @@ struct config_item {
  */
 MEMCACHED_PUBLIC_API int parse_config(const char *str, struct config_item items[], FILE *error);
 
+int read_config_file(const char *fname, struct config_item items[], FILE *error);
 #ifdef __cplusplus
 }
 #endif

memcached.c

@@ -163,6 +163,7 @@ static void write_and_free(conn *c, char *buf, int bytes);
 static int ensure_iov_space(conn *c);
 static int add_iov(conn *c, const void *buf, int len);
 static int add_msghdr(conn *c);
+static int try_load_config_file(const char *path, config_opt_t *opt);
 
 enum transmit_result {
     TRANSMIT_COMPLETE,   /** All done writing. */
@@ -15804,6 +15805,116 @@ static bool sanitycheck(void)
     return true;
 }
 
+static int try_load_config_file(const char *path, config_opt_t *opt)
+{
+    char *access_mask_str = NULL;
+    char *protocol_str = NULL;
+
+    struct config_item main_config_items[] = {
+        { .key = "port",          .datatype = DT_UINT32, .value.dt_uint32 = (uint32_t*)&settings.port },
+        { .key = "udpport",       .datatype = DT_UINT32, .value.dt_uint32 = (uint32_t*)&settings.udpport },
+        { .key = "socketpath",    .datatype = DT_STRING, .value.dt_string = &settings.socketpath },
+        { .key = "access",        .datatype = DT_STRING, .value.dt_string = &access_mask_str },
+        { .key = "listen",        .datatype = DT_STRING, .value.dt_string = &settings.inter },
+        { .key = "daemonize",     .datatype = DT_BOOL,   .value.dt_bool = opt->daemonize },
+        { .key = "maxcore",       .datatype = DT_BOOL,   .value.dt_bool = opt->maxcore },
+        { .key = "username",      .datatype = DT_STRING, .value.dt_string = opt->username },
+        { .key = "maxconns",      .datatype = DT_UINT32, .value.dt_uint32 = (uint32_t*)&settings.maxconns },
+        { .key = "lock_memory",   .datatype = DT_BOOL,   .value.dt_bool = opt->lock_memory },
+        { .key = "verbosity",     .datatype = DT_SIZE,   .value.dt_size   = (size_t*)&settings.verbose },
+        { .key = "pid_file",      .datatype = DT_STRING, .value.dt_string = opt->pid_file },
+        { .key = "threads",       .datatype = DT_UINT32, .value.dt_uint32 = (uint32_t*)&settings.num_threads },
+        { .key = "reqs_per_event", .datatype = DT_UINT32, .value.dt_uint32 = (uint32_t*)&settings.reqs_per_event },
+        { .key = "backlog",       .datatype = DT_UINT32, .value.dt_uint32 = (uint32_t*)&settings.backlog },
+        { .key = "protocol",      .datatype = DT_STRING, .value.dt_string = &protocol_str },
+        { .key = "engine_path", .datatype = DT_STRING, .value.dt_string = opt->engine },
+
+        { .key = "memory_limit",  .datatype = DT_SIZE,   .value.dt_size   = &settings.maxbytes },
+        { .key = "eviction",      .datatype = DT_BOOL,   .value.dt_bool   = (bool*)&settings.evict_to_free },
+        { .key = "sticky_limit",  .datatype = DT_SIZE,   .value.dt_size   = &settings.sticky_limit },
+        { .key = "factor",        .datatype = DT_FLOAT,  .value.dt_float  = (float*)&settings.factor },
+        { .key = "chunk_size",    .datatype = DT_SIZE,   .value.dt_size   = (size_t*)&settings.chunk_size },
+        { .key = "prefix_delimiter", .datatype = DT_CHAR, .value.dt_char = &settings.prefix_delimiter},
+        { .key = "use_cas",       .datatype = DT_BOOL,   .value.dt_bool   = &settings.use_cas },
+        { .key = "item_size_max", .datatype = DT_SIZE,   .value.dt_size   = &settings.item_size_max },
+        { .key = "engine_config", .datatype = DT_STRING, .value.dt_string = (char**)opt->engine_config },
+        { .key = "preallocate",   .datatype = DT_BOOL,   .value.dt_bool   = opt->preallocate },
+#ifdef ENABLE_ZK_INTEGRATION
+{ .key = "zookeeper",   .datatype = DT_STRING, .value.dt_string = (char**)&arcus_zk_cfg },
+{ .key = "zk_timeout",  .datatype = DT_UINT32, .value.dt_uint32 = (uint32_t*)arcus_zk_to_ptr },
+#ifdef PROXY_SUPPORT
+        { .key = "proxy_config",  .datatype = DT_STRING, .value.dt_string = opt->arcus_proxy_cfg },
+#endif
+#endif
+
+#ifdef SASL_ENABLED
+        { .key = "require_sasl",  .datatype = DT_BOOL,   .value.dt_bool   = &settings.require_sasl },
+#endif
+        { .key = NULL}
+    };
+
+    if (read_config_file(path, main_config_items, stderr) == -1) {
+        fprintf(stderr, "Error parsing config file. Aborting.\n");
+        return -1;
+    }
+
+    if (access_mask_str != NULL) {
+        settings.access = strtol(access_mask_str, NULL, 8);
+        free(access_mask_str);
+    }
+    if (protocol_str != NULL) {
+        if (strcmp(protocol_str, "auto") == 0) {
+            settings.binding_protocol = negotiating_prot;
+        } else if (strcmp(protocol_str, "binary") == 0) {
+            settings.binding_protocol = binary_prot;
+        } else if (strcmp(protocol_str, "ascii") == 0) {
+            settings.binding_protocol = ascii_prot;
+        } else {
+            fprintf(stderr, "Invalid value for binding protocol in config file: %s\n", protocol_str);
+            free(protocol_str);
+            return -1;
+        }
+        free(protocol_str);
+    }
+    if (settings.maxbytes <= 0) {
+        mc_logger->log(EXTENSION_LOG_WARNING, NULL,
+                       "The value of memory limit must be greater than 0.\n");
+        return -1;
+    }
+    if (settings.sticky_limit > 0 && settings.maxbytes < settings.sticky_limit) {
+        mc_logger->log(EXTENSION_LOG_WARNING, NULL,
+                       "The value of memory limit cannot be smaller than sticky_limit.\n");
+        return -1;
+    }
+    if (settings.item_size_max < 1024 * 20) {
+        mc_logger->log(EXTENSION_LOG_WARNING, NULL,
+                       "Item max size cannot be less than 20KB.\n");
+        return -1;
+    }
+    if (settings.item_size_max > 1024 * 1024 * 128) {
+        mc_logger->log(EXTENSION_LOG_WARNING, NULL,
+                       "Cannot set item size limit higher than 128 mb.\n");
+        return -1;
+    }
+    if (settings.factor <= 1.0) {
+        mc_logger->log(EXTENSION_LOG_WARNING, NULL,
+                       "Factor must be greater than 1\n");
+        return -1;
+    }
+    if (settings.chunk_size <= 0) {
+        mc_logger->log(EXTENSION_LOG_WARNING, NULL,
+                       "Chunk size must be greater than 0\n");
+        return -1;
+    }
+    if (settings.num_threads <= 0) {
+        mc_logger->log(EXTENSION_LOG_WARNING, NULL,
+                       "Number of threads must be greater than 0\n");
+        return -1;
+    }
+
+    return 0;
+}
+
 static void settings_reload_engine_config(void)
 {
     ENGINE_ERROR_CODE ret;
@@ -15898,6 +16009,35 @@ int main (int argc, char **argv)
         return EX_OSERR;
     }
 
+    /* parse config file */
+    if (argc > 1 && argv[1][0] != '-') {
+        const char *config_file = argv[1];
+        config_opt_t opt = {
+            .daemonize = &do_daemonize,
+            .maxcore = (bool*)&maxcore,
+            .username = &username,
+            .lock_memory = &lock_memory,
+            .pid_file = &pid_file,
+            .engine = (char**)&engine,
+            .engine_config = &engine_config,
+            .preallocate = &preallocate,
+#ifdef ENABLE_ZK_INTEGRATION
+            .arcus_zk_to = &arcus_zk_to,
+#ifdef PROXY_SUPPORT
+            .arcus_proxy_cfg = &arcus_proxy_cfg,
+#endif
+#endif
+        };
+        if (try_load_config_file(config_file, &opt) != 0) {
+            fprintf(stderr, "Error parsing config file '%s'.", config_file);
+            exit(EXIT_FAILURE);
+        }
+
+        optind = 2;
+    } else {
+        optind = 1;
+    }
+
     /* process arguments */
     while (-1 != (c = getopt(argc, argv,
           "a:"  /* access mask for unix socket */

memcached.h

@@ -260,6 +260,24 @@ extern struct settings settings;
 extern EXTENSION_LOGGER_DESCRIPTOR *mc_logger;
 extern union mc_engine mc_engine;
 
+typedef struct {
+    bool *daemonize;
+    bool *maxcore;
+    char **username;
+    bool *lock_memory;
+    char **pid_file;
+    char *protocol;
+    char **engine;
+    const char **engine_config;
+    bool *preallocate;
+#ifdef ENABLE_ZK_INTEGRATION
+    int *arcus_zk_to;
+#endif
+#ifdef PROXY_SUPPORT
+    char **arcus_proxy_cfg;
+#endif
+} config_opt_t;
+
 typedef struct conn conn;
 typedef bool (*STATE_FUNC)(conn *);