Skip to content

Open Source alternative to Algolia + Pinecone and an Easier-to-Use alternative to ElasticSearch ⚡ 🔍 ✨ Fast, typo tolerant, in-memory fuzzy Search Engine for building delightful search experiences

Read configuration from a configuration file.

Kishore Nallanbfdc31f8d8cc
diff --git a/include/INIReader.h b/include/INIReader.h
new file mode 100644
index 00000000..05e2bb2c
--- /dev/null
+++ b/include/INIReader.h
@@ -0,0 +1,449 @@
+// Read an INI file into easy-to-access name/value pairs.
+
+// inih and INIReader are released under the New BSD license (see LICENSE.txt).
+// Go to the project home page for more info:
+//
+// https://github.com/benhoyt/inih
+/* inih -- simple .INI file parser
+inih is released under the New BSD license (see LICENSE.txt). Go to the project
+home page for more info:
+https://github.com/benhoyt/inih
+*/
+
+#ifndef __INI_H__
+#define __INI_H__
+
+/* Make this header file easier to include in C++ code */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+
+/* Typedef for prototype of handler function. */
+typedef int (*ini_handler)(void* user, const char* section,
+ const char* name, const char* value);
+
+/* Typedef for prototype of fgets-style reader function. */
+typedef char* (*ini_reader)(char* str, int num, void* stream);
+
+/* Parse given INI-style file. May have [section]s, name=value pairs
+ (whitespace stripped), and comments starting with ';' (semicolon). Section
+ is "" if name=value pair parsed before any section heading. name:value
+ pairs are also supported as a concession to Python's configparser.
+ For each name=value pair parsed, call handler function with given user
+ pointer as well as section, name, and value (data only valid for duration
+ of handler call). Handler should return nonzero on success, zero on error.
+ Returns 0 on success, line number of first error on parse error (doesn't
+ stop on first error), -1 on file open error, or -2 on memory allocation
+ error (only when INI_USE_STACK is zero).
+*/
+int ini_parse(const char* filename, ini_handler handler, void* user);
+
+/* Same as ini_parse(), but takes a FILE* instead of filename. This doesn't
+ close the file when it's finished -- the caller must do that. */
+int ini_parse_file(FILE* file, ini_handler handler, void* user);
+
+/* Same as ini_parse(), but takes an ini_reader function pointer instead of
+ filename. Used for implementing custom or string-based I/O. */
+int ini_parse_stream(ini_reader reader, void* stream, ini_handler handler,
+ void* user);
+
+/* Nonzero to allow multi-line value parsing, in the style of Python's
+ configparser. If allowed, ini_parse() will call the handler with the same
+ name for each subsequent line parsed. */
+#ifndef INI_ALLOW_MULTILINE
+#define INI_ALLOW_MULTILINE 1
+#endif
+
+/* Nonzero to allow a UTF-8 BOM sequence (0xEF 0xBB 0xBF) at the start of
+ the file. See http://code.google.com/p/inih/issues/detail?id=21 */
+#ifndef INI_ALLOW_BOM
+#define INI_ALLOW_BOM 1
+#endif
+
+/* Nonzero to allow inline comments (with valid inline comment characters
+ specified by INI_INLINE_COMMENT_PREFIXES). Set to 0 to turn off and match
+ Python 3.2+ configparser behaviour. */
+#ifndef INI_ALLOW_INLINE_COMMENTS
+#define INI_ALLOW_INLINE_COMMENTS 1
+#endif
+#ifndef INI_INLINE_COMMENT_PREFIXES
+#define INI_INLINE_COMMENT_PREFIXES ";"
+#endif
+
+/* Nonzero to use stack, zero to use heap (malloc/free). */
+#ifndef INI_USE_STACK
+#define INI_USE_STACK 1
+#endif
+
+/* Stop parsing on first error (default is to keep parsing). */
+#ifndef INI_STOP_ON_FIRST_ERROR
+#define INI_STOP_ON_FIRST_ERROR 0
+#endif
+
+/* Maximum line length for any line in INI file. */
+#ifndef INI_MAX_LINE
+#define INI_MAX_LINE 200
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+/* inih -- simple .INI file parser
+inih is released under the New BSD license (see LICENSE.txt). Go to the project
+home page for more info:
+https://github.com/benhoyt/inih
+*/
+
+#if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+
+#if !INI_USE_STACK
+#include <stdlib.h>
+#endif
+
+#define MAX_SECTION 50
+#define MAX_NAME 50
+
+/* Strip whitespace chars off end of given string, in place. Return s. */
+inline static char* rstrip(char* s)
+{
+ char* p = s + strlen(s);
+ while (p > s && isspace((unsigned char)(*--p)))
+ *p = '\0';
+ return s;
+}
+
+/* Return pointer to first non-whitespace char in given string. */
+inline static char* lskip(const char* s)
+{
+ while (*s && isspace((unsigned char)(*s)))
+ s++;
+ return (char*)s;
+}
+
+/* Return pointer to first char (of chars) or inline comment in given string,
+ or pointer to null at end of string if neither found. Inline comment must
+ be prefixed by a whitespace character to register as a comment. */
+inline static char* find_chars_or_comment(const char* s, const char* chars)
+{
+#if INI_ALLOW_INLINE_COMMENTS
+ int was_space = 0;
+ while (*s && (!chars || !strchr(chars, *s)) &&
+ !(was_space && strchr(INI_INLINE_COMMENT_PREFIXES, *s))) {
+ was_space = isspace((unsigned char)(*s));
+ s++;
+ }
+#else
+ while (*s && (!chars || !strchr(chars, *s))) {
+ s++;
+ }
+#endif
+ return (char*)s;
+}
+
+/* Version of strncpy that ensures dest (size bytes) is null-terminated. */
+inline static char* strncpy0(char* dest, const char* src, size_t size)
+{
+ strncpy(dest, src, size);
+ dest[size - 1] = '\0';
+ return dest;
+}
+
+/* See documentation in header file. */
+inline int ini_parse_stream(ini_reader reader, void* stream, ini_handler handler,
+ void* user)
+{
+ /* Uses a fair bit of stack (use heap instead if you need to) */
+#if INI_USE_STACK
+ char line[INI_MAX_LINE];
+#else
+ char* line;
+#endif
+ char section[MAX_SECTION] = "";
+ char prev_name[MAX_NAME] = "";
+
+ char* start;
+ char* end;
+ char* name;
+ char* value;
+ int lineno = 0;
+ int error = 0;
+
+#if !INI_USE_STACK
+ line = (char*)malloc(INI_MAX_LINE);
+ if (!line) {
+ return -2;
+ }
+#endif
+
+ /* Scan through stream line by line */
+ while (reader(line, INI_MAX_LINE, stream) != NULL) {
+ lineno++;
+
+ start = line;
+#if INI_ALLOW_BOM
+ if (lineno == 1 && (unsigned char)start[0] == 0xEF &&
+ (unsigned char)start[1] == 0xBB &&
+ (unsigned char)start[2] == 0xBF) {
+ start += 3;
+ }
+#endif
+ start = lskip(rstrip(start));
+
+ if (*start == ';' || *start == '#') {
+ /* Per Python configparser, allow both ; and # comments at the
+ start of a line */
+ }
+#if INI_ALLOW_MULTILINE
+ else if (*prev_name && *start && start > line) {
+
+#if INI_ALLOW_INLINE_COMMENTS
+ end = find_chars_or_comment(start, NULL);
+ if (*end)
+ *end = '\0';
+ rstrip(start);
+#endif
+
+ /* Non-blank line with leading whitespace, treat as continuation
+ of previous name's value (as per Python configparser). */
+ if (!handler(user, section, prev_name, start) && !error)
+ error = lineno;
+ }
+#endif
+ else if (*start == '[') {
+ /* A "[section]" line */
+ end = find_chars_or_comment(start + 1, "]");
+ if (*end == ']') {
+ *end = '\0';
+ strncpy0(section, start + 1, sizeof(section));
+ *prev_name = '\0';
+ }
+ else if (!error) {
+ /* No ']' found on section line */
+ error = lineno;
+ }
+ }
+ else if (*start) {
+ /* Not a comment, must be a name[=:]value pair */
+ end = find_chars_or_comment(start, "=:");
+ if (*end == '=' || *end == ':') {
+ *end = '\0';
+ name = rstrip(start);
+ value = lskip(end + 1);
+#if INI_ALLOW_INLINE_COMMENTS
+ end = find_chars_or_comment(value, NULL);
+ if (*end)
+ *end = '\0';
+#endif
+ rstrip(value);
+
+ /* Valid name[=:]value pair found, call handler */
+ strncpy0(prev_name, name, sizeof(prev_name));
+ if (!handler(user, section, name, value) && !error)
+ error = lineno;
+ }
+ else if (!error) {
+ /* No '=' or ':' found on name[=:]value line */
+ error = lineno;
+ }
+ }
+
+#if INI_STOP_ON_FIRST_ERROR
+ if (error)
+ break;
+#endif
+ }
+
+#if !INI_USE_STACK
+ free(line);
+#endif
+
+ return error;
+}
+
+/* See documentation in header file. */
+inline int ini_parse_file(FILE* file, ini_handler handler, void* user)
+{
+ return ini_parse_stream((ini_reader)fgets, file, handler, user);
+}
+
+/* See documentation in header file. */
+inline int ini_parse(const char* filename, ini_handler handler, void* user)
+{
+ FILE* file;
+ int error;
+
+ file = fopen(filename, "r");
+ if (!file)
+ return -1;
+ error = ini_parse_file(file, handler, user);
+ fclose(file);
+ return error;
+}
+
+#endif /* __INI_H__ */
+
+
+#ifndef __INIREADER_H__
+#define __INIREADER_H__
+
+#include <map>
+#include <set>
+#include <string>
+
+// Read an INI file into easy-to-access name/value pairs. (Note that I've gone
+// for simplicity here rather than speed, but it should be pretty decent.)
+class INIReader
+{
+public:
+ // Empty Constructor
+ INIReader() {};
+
+ // Construct INIReader and parse given filename. See ini.h for more info
+ // about the parsing.
+ INIReader(std::string filename);
+
+ // Construct INIReader and parse given file. See ini.h for more info
+ // about the parsing.
+ INIReader(FILE *file);
+
+ // Return the result of ini_parse(), i.e., 0 on success, line number of
+ // first error on parse error, or -1 on file open error.
+ int ParseError() const;
+
+ // Return the list of sections found in ini file
+ const std::set<std::string>& Sections() const;
+
+ // Checks for the presence of a key
+ bool Exists(std::string section, std::string name) const;
+
+ // Get a string value from INI file, returning default_value if not found.
+ std::string Get(std::string section, std::string name,
+ std::string default_value) const;
+
+ // Get an integer (long) value from INI file, returning default_value if
+ // not found or not a valid integer (decimal "1234", "-1234", or hex "0x4d2").
+ long GetInteger(std::string section, std::string name, long default_value) const;
+
+ // Get a real (floating point double) value from INI file, returning
+ // default_value if not found or not a valid floating point value
+ // according to strtod().
+ double GetReal(std::string section, std::string name, double default_value) const;
+
+ // Get a boolean value from INI file, returning default_value if not found or if
+ // not a valid true/false value. Valid true values are "true", "yes", "on", "1",
+ // and valid false values are "false", "no", "off", "0" (not case sensitive).
+ bool GetBoolean(std::string section, std::string name, bool default_value) const;
+
+protected:
+ int _error;
+ std::map<std::string, std::string> _values;
+ std::set<std::string> _sections;
+ static std::string MakeKey(std::string section, std::string name);
+ static int ValueHandler(void* user, const char* section, const char* name,
+ const char* value);
+};
+
+#endif // __INIREADER_H__
+
+
+#ifndef __INIREADER__
+#define __INIREADER__
+
+#include <algorithm>
+#include <cctype>
+#include <cstdlib>
+
+inline INIReader::INIReader(std::string filename)
+{
+ _error = ini_parse(filename.c_str(), ValueHandler, this);
+}
+
+inline INIReader::INIReader(FILE *file)
+{
+ _error = ini_parse_file(file, ValueHandler, this);
+}
+
+inline int INIReader::ParseError() const
+{
+ return _error;
+}
+
+inline const std::set<std::string>& INIReader::Sections() const
+{
+ return _sections;
+}
+
+inline bool INIReader::Exists(std::string section, std::string name) const
+{
+ std::string key = MakeKey(section, name);
+ return _values.count(key) != 0;
+}
+
+inline std::string INIReader::Get(std::string section, std::string name, std::string default_value) const
+{
+ std::string key = MakeKey(section, name);
+ return _values.count(key) ? _values.at(key) : default_value;
+}
+
+inline long INIReader::GetInteger(std::string section, std::string name, long default_value) const
+{
+ std::string valstr = Get(section, name, "");
+ const char* value = valstr.c_str();
+ char* end;
+ // This parses "1234" (decimal) and also "0x4D2" (hex)
+ long n = strtol(value, &end, 0);
+ return end > value ? n : default_value;
+}
+
+inline double INIReader::GetReal(std::string section, std::string name, double default_value) const
+{
+ std::string valstr = Get(section, name, "");
+ const char* value = valstr.c_str();
+ char* end;
+ double n = strtod(value, &end);
+ return end > value ? n : default_value;
+}
+
+inline bool INIReader::GetBoolean(std::string section, std::string name, bool default_value) const
+{
+ std::string valstr = Get(section, name, "");
+ // Convert to lower case to make string comparisons case-insensitive
+ std::transform(valstr.begin(), valstr.end(), valstr.begin(), ::tolower);
+ if (valstr == "true" || valstr == "yes" || valstr == "on" || valstr == "1")
+ return true;
+ else if (valstr == "false" || valstr == "no" || valstr == "off" || valstr == "0")
+ return false;
+ else
+ return default_value;
+}
+
+inline std::string INIReader::MakeKey(std::string section, std::string name)
+{
+ std::string key = section + "=" + name;
+ // Convert to lower case to make section/name lookups case-insensitive
+ std::transform(key.begin(), key.end(), key.begin(), ::tolower);
+ return key;
+}
+
+inline int INIReader::ValueHandler(void* user, const char* section, const char* name,
+ const char* value)
+{
+ INIReader* reader = (INIReader*)user;
+ std::string key = MakeKey(section, name);
+ if (reader->_values[key].size() > 0)
+ reader->_values[key] += "\n";
+ reader->_values[key] += value;
+ reader->_sections.insert(section);
+ return 1;
+}
+
+#endif // __INIREADER__
\ No newline at end of file
diff --git a/include/config.h b/include/config.h
index 820efaf2..ec7e9cf2 100644
--- a/include/config.h
+++ b/include/config.h
@@ -3,6 +3,7 @@
#include <cmdline.h>
#include "option.h"
#include "string_utils.h"
+#include "INIReader.h"
class Config {
private:
@@ -22,6 +23,9 @@ private:
bool enable_cors;
+ std::string config_file;
+ int config_file_validity;
+
public:
Config() {
@@ -148,40 +152,121 @@ public:
this->enable_cors = ("TRUE" == enable_cors_str) ? true : false;
}
+ void load_config_file(cmdline::parser & options) {
+ this->config_file = options.exist("config") ? options.get<std::string>("config") : "";
+
+ if(!options.exist("config")) {
+ config_file_validity = 0;
+ return;
+ }
+
+ this->config_file = options.get<std::string>("config");
+
+ INIReader reader(this->config_file);
+
+ if (reader.ParseError() != 0) {
+ config_file_validity = -1;
+ return ;
+ }
+
+ config_file_validity = 1;
+
+ if(reader.Exists("server", "data-dir")) {
+ this->data_dir = reader.Get("server", "data-dir", "");
+ }
+
+ if(reader.Exists("server", "log-dir")) {
+ this->log_dir = reader.Get("server", "log-dir", "");
+ }
+
+ if(reader.Exists("server", "api-key")) {
+ this->api_key = reader.Get("server", "api-key", "");
+ }
+
+ if(reader.Exists("server", "search-only-api-key")) {
+ this->search_only_api_key = reader.Get("server", "search-only-api-key", "");
+ }
+
+ if(reader.Exists("server", "listen-address")) {
+ this->listen_address = reader.Get("server", "listen-address", "");
+ }
+
+ if(reader.Exists("server", "master")) {
+ this->master = reader.Get("server", "master", "");
+ }
+
+ if(reader.Exists("server", "ssl-certificate")) {
+ this->ssl_certificate = reader.Get("server", "ssl-certificate", "");
+ }
+
+ if(reader.Exists("server", "ssl-certificate-key")) {
+ this->ssl_certificate_key = reader.Get("server", "ssl-certificate-key", "");
+ }
+
+ if(reader.Exists("server", "listen-port")) {
+ this->listen_port = reader.GetInteger("server", "listen-port", 8108);
+ }
+
+ if(reader.Exists("server", "enable-cors")) {
+ this->enable_cors = reader.GetBoolean("server", "enable-cors", false);
+ }
+ }
+
void load_config_cmd_args(cmdline::parser & options) {
- this->data_dir = options.exist("data-dir") ? options.get<std::string>("data-dir") : "";
- this->log_dir = options.exist("log-dir") ? options.get<std::string>("log-dir") : "";
- this->api_key = options.exist("api-key") ? options.get<std::string>("api-key") : "";
+ if(options.exist("data-dir")) {
+ this->data_dir = options.get<std::string>("data-dir");
+ }
+
+ if(options.exist("log-dir")) {
+ this->log_dir = options.get<std::string>("log-dir");
+ }
+
+ if(options.exist("api-key")) {
+ this->api_key = options.get<std::string>("api-key");
+ }
- this->search_only_api_key = options.exist("search-only-api-key") ?
- options.get<std::string>("search-only-api-key") : "";
+ if(options.exist("search-only-api-key")) {
+ this->search_only_api_key = options.get<std::string>("search-only-api-key");
+ }
if(options.exist("listen-address")) {
this->listen_address = options.get<std::string>("listen-address");
}
+ if(options.exist("master")) {
+ this->master = options.get<std::string>("master");
+ }
+
+ if(options.exist("ssl-certificate")) {
+ this->ssl_certificate = options.get<std::string>("ssl-certificate");
+ }
+
+ if(options.exist("ssl-certificate-key")) {
+ this->ssl_certificate_key = options.get<std::string>("ssl-certificate-key");
+ }
+
if(options.exist("listen-port")) {
this->listen_port = options.get<uint32_t>("listen-port");
}
- this->master = options.exist("master") ? options.get<std::string>("master") : "";
- this->ssl_certificate = options.exist("ssl-certificate") ?
- options.get<std::string>("ssl-certificate") : "";
- this->ssl_certificate_key = options.exist("ssl-certificate-key") ?
- options.get<std::string>("ssl-certificate-key") : "";
-
- this->enable_cors = options.exist("enable-cors");
+ if(options.exist("enable-cors")) {
+ this->enable_cors = options.exist("enable-cors");
+ }
}
// validation
Option<bool> is_valid() {
+ if(this->config_file_validity == -1) {
+ return Option<bool>(500, "Error parsing the configuration file.");
+ }
+
if(data_dir.empty()) {
- return Option<bool>(404, "Data directory is not specified.");
+ return Option<bool>(500, "Data directory is not specified.");
}
if(api_key.empty()) {
- return Option<bool>(404, "API key is not specified.");
+ return Option<bool>(500, "API key is not specified.");
}
return Option<bool>(true);
diff --git a/src/main/typesense_server.cpp b/src/main/typesense_server.cpp
index e94aa6ef..ed60b662 100644
--- a/src/main/typesense_server.cpp
+++ b/src/main/typesense_server.cpp
@@ -50,6 +50,7 @@ int main(int argc, char **argv) {
// Command line args override env vars
config.load_config_env();
+ config.load_config_file(options);
config.load_config_cmd_args(options);
Option<bool> config_validitation = config.is_valid();
diff --git a/src/typesense_server_utils.cpp b/src/typesense_server_utils.cpp
index 766905a7..b1556aaf 100644
--- a/src/typesense_server_utils.cpp
+++ b/src/typesense_server_utils.cpp
@@ -32,7 +32,10 @@ void init_cmdline_options(cmdline::parser & options, int argc, char **argv) {
options.add<std::string>("ssl-certificate-key", 'k', "Path to the SSL certificate key file.", false, "");
options.add("enable-cors", '\0', "Enable CORS requests.");
+
options.add<std::string>("log-dir", '\0', "Path to the log directory.", false, "");
+
+ options.add<std::string>("config", '\0', "Path to the configuration file.", false, "");
}
int init_logger(Config & config, std::unique_ptr<g3::LogWorker> & log_worker) {
diff --git a/test/bad_config.ini b/test/bad_config.ini
new file mode 100644
index 00000000..d8b381f4
--- /dev/null
+++ b/test/bad_config.ini
@@ -0,0 +1,5 @@
+; Bad Typesense Configuration
+
+[foobar
+
+data-dir: /tmp/ts
diff --git a/test/config_test.cpp b/test/config_test.cpp
index 98be66c8..143cb1b0 100644
--- a/test/config_test.cpp
+++ b/test/config_test.cpp
@@ -1,15 +1,17 @@
#include <gtest/gtest.h>
#include <stdlib.h>
+#include <iostream>
#include <cmdline.h>
#include "typesense_server_utils.h"
#include "config.h"
std::vector<char*> get_argv(std::vector<std::string> & args) {
std::vector<char*> argv;
- for (const auto& arg : args)
+ for (const auto& arg : args) {
argv.push_back((char*)arg.data());
- argv.push_back(nullptr);
+ }
+ argv.push_back(nullptr);
return argv;
}
@@ -47,44 +49,116 @@ TEST(ConfigTest, LoadEnvVars) {
ASSERT_EQ(9090, config.get_listen_port());
}
-TEST(ConfigTest, CmdLineArgsOverrideEnvVars) {
+TEST(ConfigTest, BadConfigurationReturnsError) {
+ Config config1;
+ config1.set_api_key("abcd");
+ auto validation = config1.is_valid();
+
+ ASSERT_EQ(false, validation.ok());
+ ASSERT_EQ("Data directory is not specified.", validation.error());
+
+ Config config2;
+ config2.set_data_dir("/tmp/ts");
+ validation = config2.is_valid();
+
+ ASSERT_EQ(false, validation.ok());
+ ASSERT_EQ("API key is not specified.", validation.error());
+}
+
+TEST(ConfigTest, LoadConfigFile) {
cmdline::parser options;
std::vector<std::string> args = {
- "./typesense-server",
- "--data-dir=/tmp/data",
- "--api-key=abcd"
+ "./typesense-server",
+ std::string("--config=") + std::string(ROOT_DIR)+"test/valid_config.ini"
};
-
- putenv((char*)"TYPESENSE_DATA_DIR=/tmp/ts");
- putenv((char*)"TYPESENSE_LISTEN_PORT=9090");
-
std::vector<char*> argv = get_argv(args);
-
init_cmdline_options(options, argv.size() - 1, argv.data());
options.parse(argv.size() - 1, argv.data());
Config config;
- config.load_config_env();
- config.load_config_cmd_args(options);
+ config.load_config_file(options);
- ASSERT_EQ("abcd", config.get_api_key());
- ASSERT_EQ("/tmp/data", config.get_data_dir());
+ auto validation = config.is_valid();
+ ASSERT_EQ(true, validation.ok());
+
+ ASSERT_EQ("/tmp/ts", config.get_data_dir());
+ ASSERT_EQ("1234", config.get_api_key());
+ ASSERT_EQ("/tmp/logs", config.get_log_dir());
ASSERT_EQ(9090, config.get_listen_port());
+ ASSERT_EQ(false, config.get_enable_cors());
}
-TEST(ConfigTest, BadConfigurationReturnsError) {
- Config config1;
- config1.set_api_key("abcd");
- auto validation = config1.is_valid();
+TEST(ConfigTest, LoadIncompleteConfigFile) {
+ cmdline::parser options;
+
+ std::vector<std::string> args = {
+ "./typesense-server",
+ std::string("--config=") + std::string(ROOT_DIR)+"test/valid_sparse_config.ini"
+ };
+ std::vector<char*> argv = get_argv(args);
+ init_cmdline_options(options, argv.size() - 1, argv.data());
+ options.parse(argv.size() - 1, argv.data());
+
+ Config config;
+
+ auto validation = config.is_valid();
ASSERT_EQ(false, validation.ok());
ASSERT_EQ("Data directory is not specified.", validation.error());
+}
- Config config2;
- config2.set_data_dir("/tmp/ts");
- validation = config2.is_valid();
+TEST(ConfigTest, LoadBadConfigFile) {
+ cmdline::parser options;
+ std::vector<std::string> args = {
+ "./typesense-server",
+ std::string("--config=") + std::string(ROOT_DIR)+"test/bad_config.ini"
+ };
+ std::vector<char*> argv = get_argv(args);
+ init_cmdline_options(options, argv.size() - 1, argv.data());
+ options.parse(argv.size() - 1, argv.data());
+
+ Config config;
+ config.load_config_file(options);
+
+ auto validation = config.is_valid();
ASSERT_EQ(false, validation.ok());
- ASSERT_EQ("API key is not specified.", validation.error());
+ ASSERT_EQ("Error parsing the configuration file.", validation.error());
}
+
+TEST(ConfigTest, CmdLineArgsOverrideConfigFileAndEnvVars) {
+ cmdline::parser options;
+
+ std::vector<std::string> args = {
+ "./typesense-server",
+ "--data-dir=/tmp/data",
+ "--api-key=abcd",
+ "--listen-address=192.168.10.10",
+ std::string("--config=") + std::string(ROOT_DIR)+"test/valid_sparse_config.ini"
+ };
+
+ putenv((char*)"TYPESENSE_DATA_DIR=/tmp/ts");
+ putenv((char*)"TYPESENSE_LOG_DIR=/tmp/ts_log");
+ putenv((char*)"TYPESENSE_LISTEN_PORT=9090");
+ putenv((char*)"TYPESENSE_LISTEN_ADDRESS=127.0.0.1");
+ putenv((char*)"TYPESENSE_ENABLE_CORS=TRUE");
+ putenv((char*)"TYPESENSE_SEARCH_ONLY_API_KEY=envsecret");
+
+ std::vector<char*> argv = get_argv(args);
+ init_cmdline_options(options, argv.size() - 1, argv.data());
+ options.parse(argv.size() - 1, argv.data());
+
+ Config config;
+ config.load_config_env();
+ config.load_config_file(options);
+ config.load_config_cmd_args(options);
+
+ ASSERT_EQ("abcd", config.get_api_key());
+ ASSERT_EQ("/tmp/data", config.get_data_dir());
+ ASSERT_EQ("/tmp/ts_log", config.get_log_dir());
+ ASSERT_EQ(9090, config.get_listen_port());
+ ASSERT_EQ(true, config.get_enable_cors());
+ ASSERT_EQ("192.168.10.10", config.get_listen_address());
+ ASSERT_EQ("supersecret", config.get_search_only_api_key());
+}
\ No newline at end of file
diff --git a/test/valid_config.ini b/test/valid_config.ini
new file mode 100644
index 00000000..505bec16
--- /dev/null
+++ b/test/valid_config.ini
@@ -0,0 +1,10 @@
+; Sample Typesense Configuration
+
+[server]
+
+data-dir = /tmp/ts
+api-key = 1234
+
+log-dir = /tmp/logs
+
+listen-port = 9090
diff --git a/test/valid_sparse_config.ini b/test/valid_sparse_config.ini
new file mode 100644
index 00000000..5991c603
--- /dev/null
+++ b/test/valid_sparse_config.ini
@@ -0,0 +1,5 @@
+; Sample Typesense Configuration
+
+[server]
+search-only-api-key = supersecret
+listen-address = localhost