Line data Source code
1 : /*
2 : * Copyright (c) 2014 Juniper Networks, Inc. All rights reserved.
3 : * Copyright Contributors to the OpenSDN project
4 : */
5 : #include "options.h"
6 :
7 : #include <fstream>
8 : #include <iostream>
9 : #include <boost/foreach.hpp>
10 : #include <boost/assign/list_of.hpp>
11 : #include <boost/assign/list_of.hpp>
12 : #include <boost/functional/hash.hpp>
13 :
14 : #include <analytics/buildinfo.h>
15 : #include "base/contrail_ports.h"
16 : #include "base/logging.h"
17 : #include "base/misc_utils.h"
18 : #include "base/address_util.h"
19 : #include "base/util.h"
20 : #include <base/options_util.h>
21 : #include <analytics/viz_constants.h>
22 : #include <database/gendb_constants.h>
23 :
24 : #include "config-client-mgr/config_client_manager.h"
25 :
26 : using namespace std;
27 : using namespace boost::asio::ip;
28 : using namespace boost::assign;
29 : namespace opt = boost::program_options;
30 : using namespace options::util;
31 :
32 : // Process command line options for collector .
33 8 : Options::Options() {
34 8 : }
35 :
36 8 : bool Options::Parse(EventManager &evm, int argc, char *argv[]) {
37 16 : opt::options_description cmdline_options("Allowed options");
38 8 : Initialize(evm, cmdline_options);
39 :
40 8 : Process(argc, argv, cmdline_options);
41 8 : return true;
42 8 : }
43 :
44 : // Initialize collector's command line option tags with appropriate default
45 : // values. Options can from a config file as well. By default, we read
46 : // options from /etc/contrail/contrail-collector.conf
47 8 : void Options::Initialize(EventManager &evm,
48 : opt::options_description &cmdline_options) {
49 8 : boost::system::error_code error;
50 8 : string hostname = ResolveCanonicalName();
51 8 : string host_ip = GetHostIp(evm.io_service(), hostname);
52 :
53 8 : if (host_ip.empty()) {
54 : cout << "Error! Cannot resolve host " << hostname <<
55 0 : "to a valid IP address";
56 0 : exit(-1);
57 : }
58 :
59 : map<string, vector<string> >::const_iterator it =
60 8 : g_vns_constants.ServicesDefaultConfigurationFiles.find(
61 : g_vns_constants.SERVICE_COLLECTOR);
62 8 : assert(it != g_vns_constants.ServicesDefaultConfigurationFiles.end());
63 8 : const vector<string> &conf_files(it->second);
64 :
65 16 : opt::options_description generic("Generic options");
66 :
67 : // Command line only options.
68 8 : ostringstream conf_files_oss;
69 8 : bool first = true;
70 56 : BOOST_FOREACH(const string &cfile, conf_files) {
71 24 : if (first) {
72 8 : conf_files_oss << cfile;
73 8 : first = false;
74 : } else {
75 16 : conf_files_oss << ", " << cfile;
76 : }
77 : }
78 8 : generic.add_options()
79 16 : ("conf_file", opt::value<vector<string> >()->default_value(
80 16 : conf_files, conf_files_oss.str()),
81 : "Configuration file")
82 8 : ("help", "help message")
83 8 : ("version", "Display version information")
84 : ;
85 :
86 8 : uint16_t default_redis_port = ContrailPorts::RedisUvePort();
87 8 : uint16_t default_ks_port = ContrailPorts::KeystonePort();
88 8 : uint16_t default_collector_port = ContrailPorts::CollectorPort();
89 : uint16_t default_collector_structured_syslog_port =
90 8 : ContrailPorts::CollectorStructuredSyslogPort();
91 8 : uint16_t default_partitions = 15;
92 8 : uint16_t default_http_server_port = ContrailPorts::HttpPortCollector();
93 8 : uint32_t default_disk_usage_percentage_high_watermark0 = 90;
94 8 : uint32_t default_disk_usage_percentage_low_watermark0 = 85;
95 8 : uint32_t default_disk_usage_percentage_high_watermark1 = 80;
96 8 : uint32_t default_disk_usage_percentage_low_watermark1 = 75;
97 8 : uint32_t default_disk_usage_percentage_high_watermark2 = 70;
98 8 : uint32_t default_disk_usage_percentage_low_watermark2 = 60;
99 8 : uint32_t default_pending_compaction_tasks_high_watermark0 = 400;
100 8 : uint32_t default_pending_compaction_tasks_low_watermark0 = 300;
101 8 : uint32_t default_pending_compaction_tasks_high_watermark1 = 200;
102 8 : uint32_t default_pending_compaction_tasks_low_watermark1 = 150;
103 8 : uint32_t default_pending_compaction_tasks_high_watermark2 = 100;
104 8 : uint32_t default_pending_compaction_tasks_low_watermark2 = 80;
105 8 : std::string default_high_watermark0_message_severity_level = "SYS_EMERG";
106 8 : std::string default_low_watermark0_message_severity_level = "SYS_ALERT";
107 8 : std::string default_high_watermark1_message_severity_level = "SYS_ERR";
108 8 : std::string default_low_watermark1_message_severity_level = "SYS_WARN";
109 8 : std::string default_high_watermark2_message_severity_level = "SYS_DEBUG";
110 8 : std::string default_low_watermark2_message_severity_level = "INVALID";
111 :
112 8 : vector<string> default_cassandra_server_list;
113 8 : string default_cassandra_server;
114 8 : default_cassandra_server_list.push_back(default_cassandra_server);
115 :
116 : // e.g. "ModuleClientState-max_sm_queue_count:AggProxySumAnomalyEWM01:AggProxySum"
117 :
118 8 : vector<string> default_kafka_broker_list;
119 8 : default_kafka_broker_list.push_back("");
120 :
121 8 : string default_api_server("127.0.0.1:8082");
122 8 : vector<string> default_api_server_list = list_of(default_api_server);
123 :
124 8 : vector<string> default_structured_syslog_tcp_forward_destination;
125 8 : default_structured_syslog_tcp_forward_destination.push_back("");
126 :
127 8 : vector<string> default_structured_syslog_kafka_broker_list;
128 8 : default_structured_syslog_kafka_broker_list.push_back("");
129 :
130 8 : string default_structured_syslog_kafka_topic("structured_syslog");
131 8 : uint16_t default_structured_syslog_kafka_partitions = 30;
132 8 : uint64_t default_structured_syslog_active_session_map_limit = 1000000;
133 :
134 : // Command line and config file options.
135 16 : opt::options_description cassandra_config("Cassandra Configuration options");
136 8 : cassandra_config.add_options()
137 16 : ("CASSANDRA.cassandra_user", opt::value<string>()->default_value(""),
138 : "Cassandra user name")
139 16 : ("CASSANDRA.cassandra_password", opt::value<string>()->default_value(""),
140 : "Cassandra password")
141 8 : ("CASSANDRA.cassandra_use_ssl", opt::bool_switch(&cassandra_options_.use_ssl_),
142 : "SSL communication enable/disable with Cassandra")
143 16 : ("CASSANDRA.cassandra_ca_certs", opt::value<string>()->default_value(""),
144 : "Path to file with CA certificates")
145 16 : ("CASSANDRA.compaction_strategy",
146 8 : opt::value<string>()->default_value(
147 : GenDb::g_gendb_constants.SIZE_TIERED_COMPACTION_STRATEGY),
148 : "Cassandra compaction strategy")
149 8 : ("CASSANDRA.flow_tables.compaction_strategy",
150 8 : opt::value<string>()->default_value(
151 : GenDb::g_gendb_constants.DATE_TIERED_COMPACTION_STRATEGY),
152 : "Cassandra compaction strategy for flow tables");
153 :
154 : // Command line and config file options.
155 16 : opt::options_description database_config("Database Configuration options");
156 8 : database_config.add_options()
157 16 : ("DATABASE.disk_usage_percentage.high_watermark0",
158 8 : opt::value<uint32_t>()->default_value(
159 : default_disk_usage_percentage_high_watermark0),
160 : "Disk usage percentage high watermark 0")
161 16 : ("DATABASE.disk_usage_percentage.low_watermark0",
162 8 : opt::value<uint32_t>()->default_value(
163 : default_disk_usage_percentage_low_watermark0),
164 : "Disk usage percentage low watermark 0")
165 16 : ("DATABASE.disk_usage_percentage.high_watermark1",
166 8 : opt::value<uint32_t>()->default_value(
167 : default_disk_usage_percentage_high_watermark1),
168 : "Disk usage percentage high watermark 1")
169 16 : ("DATABASE.disk_usage_percentage.low_watermark1",
170 8 : opt::value<uint32_t>()->default_value(
171 : default_disk_usage_percentage_low_watermark1),
172 : "Disk usage percentage low watermark 1")
173 16 : ("DATABASE.disk_usage_percentage.high_watermark2",
174 8 : opt::value<uint32_t>()->default_value(
175 : default_disk_usage_percentage_high_watermark2),
176 : "Disk usage percentage high watermark 2")
177 16 : ("DATABASE.disk_usage_percentage.low_watermark2",
178 8 : opt::value<uint32_t>()->default_value(
179 : default_disk_usage_percentage_low_watermark2),
180 : "Disk usage percentage low watermark 2")
181 16 : ("DATABASE.pending_compaction_tasks.high_watermark0",
182 8 : opt::value<uint32_t>()->default_value(
183 : default_pending_compaction_tasks_high_watermark0),
184 : "Cassandra pending compaction tasks high watermark 0")
185 16 : ("DATABASE.pending_compaction_tasks.low_watermark0",
186 8 : opt::value<uint32_t>()->default_value(
187 : default_pending_compaction_tasks_low_watermark0),
188 : "Cassandra pending compaction tasks low watermark 0")
189 16 : ("DATABASE.pending_compaction_tasks.high_watermark1",
190 8 : opt::value<uint32_t>()->default_value(
191 : default_pending_compaction_tasks_high_watermark1),
192 : "Cassandra pending compaction tasks high watermark 1")
193 16 : ("DATABASE.pending_compaction_tasks.low_watermark1",
194 8 : opt::value<uint32_t>()->default_value(
195 : default_pending_compaction_tasks_low_watermark1),
196 : "Cassandra pending compaction tasks low watermark 1")
197 16 : ("DATABASE.pending_compaction_tasks.high_watermark2",
198 8 : opt::value<uint32_t>()->default_value(
199 : default_pending_compaction_tasks_high_watermark2),
200 : "Cassandra pending compaction tasks high watermark 2")
201 16 : ("DATABASE.pending_compaction_tasks.low_watermark2",
202 8 : opt::value<uint32_t>()->default_value(
203 : default_pending_compaction_tasks_low_watermark2),
204 : "Cassandra pending compaction tasks low watermark 2")
205 16 : ("DATABASE.high_watermark0.message_severity_level",
206 8 : opt::value<string>()->default_value(
207 : default_high_watermark0_message_severity_level),
208 : "High Watermark 0 Message severity level")
209 16 : ("DATABASE.low_watermark0.message_severity_level",
210 8 : opt::value<string>()->default_value(
211 : default_low_watermark0_message_severity_level),
212 : "Low Watermark 0 Message severity level")
213 16 : ("DATABASE.high_watermark1.message_severity_level",
214 8 : opt::value<string>()->default_value(
215 : default_high_watermark1_message_severity_level),
216 : "High Watermark 1 Message severity level")
217 16 : ("DATABASE.low_watermark1.message_severity_level",
218 8 : opt::value<string>()->default_value(
219 : default_low_watermark1_message_severity_level),
220 : "Low Watermark 1 Message severity level")
221 16 : ("DATABASE.high_watermark2.message_severity_level",
222 8 : opt::value<string>()->default_value(
223 : default_high_watermark2_message_severity_level),
224 : "High Watermark 2 Message severity level")
225 16 : ("DATABASE.low_watermark2.message_severity_level",
226 8 : opt::value<string>()->default_value(
227 : default_low_watermark2_message_severity_level),
228 : "Low Watermark 2 Message severity level")
229 :
230 16 : ("DATABASE.cluster_id", opt::value<string>()->default_value(""),
231 : "Analytics Cluster Id")
232 16 : ("DATABASE.disable_all_writes",
233 8 : opt::bool_switch(&cassandra_options_.disable_all_db_writes_),
234 : "Disable all writes to the database")
235 16 : ("DATABASE.disable_statistics_writes",
236 8 : opt::bool_switch(&cassandra_options_.disable_db_stats_writes_),
237 : "Disable statistics writes to the database")
238 8 : ("DATABASE.disable_message_writes",
239 8 : opt::bool_switch(&cassandra_options_.disable_db_messages_writes_),
240 : "Disable message writes to the database")
241 : ;
242 :
243 : // Command line and config file options.
244 16 : opt::options_description collector_config("Collector Configuration options");
245 8 : collector_config.add_options()
246 8 : ("COLLECTOR.port", opt::value<uint16_t>()->default_value(
247 : default_collector_port),
248 : "Listener port of sandesh collector server")
249 16 : ("COLLECTOR.server",
250 16 : opt::value<string>()->default_value("0.0.0.0"),
251 : "IP address of sandesh collector server")
252 16 : ("STRUCTURED_SYSLOG_COLLECTOR.port",
253 8 : opt::value<uint16_t>()->default_value(
254 : default_collector_structured_syslog_port),
255 : "Listener port of Structured Syslog collector server")
256 16 : ("STRUCTURED_SYSLOG_COLLECTOR.tcp_forward_destination",
257 16 : opt::value<vector<string> >()->default_value(
258 : default_structured_syslog_tcp_forward_destination, ""),
259 : "Structured Syslog Forward Destination List")
260 16 : ("STRUCTURED_SYSLOG_COLLECTOR.kafka_broker_list",
261 16 : opt::value<vector<string> >()->default_value(
262 : default_structured_syslog_kafka_broker_list, ""),
263 : "Structured Syslog Kafka Broker List")
264 16 : ("STRUCTURED_SYSLOG_COLLECTOR.kafka_topic",
265 16 : opt::value<string>()->default_value(
266 : default_structured_syslog_kafka_topic, "structured_syslog"),
267 : "Structured Syslog Kafka Topic")
268 16 : ("STRUCTURED_SYSLOG_COLLECTOR.kafka_partitions",
269 8 : opt::value<uint16_t>()->default_value(
270 : default_structured_syslog_kafka_partitions),
271 : "Structured Syslog Number of Kafka Partitions")
272 8 : ("STRUCTURED_SYSLOG_COLLECTOR.active_session_map_limit",
273 8 : opt::value<uint64_t>()->default_value(
274 : default_structured_syslog_active_session_map_limit),
275 : "Structured Syslog Max Num of Active Sessions in Session Config Map")
276 : ;
277 :
278 : // Command line and config file options.
279 16 : opt::options_description config("Configuration options");
280 8 : config.add_options()
281 16 : ("DEFAULT.analytics_data_ttl",
282 16 : opt::value<uint64_t>()->default_value(
283 0 : g_viz_constants.TtlValuesDefault.find(
284 8 : TtlType::GLOBAL_TTL)->second),
285 : "TTL in hours for analytics data")
286 16 : ("DEFAULT.analytics_config_audit_ttl",
287 16 : opt::value<uint64_t>()->default_value(
288 0 : g_viz_constants.TtlValuesDefault.find(
289 8 : TtlType::CONFIGAUDIT_TTL)->second),
290 : "TTL in hours for analytics configuration audit data")
291 16 : ("DEFAULT.analytics_statistics_ttl",
292 16 : opt::value<uint64_t>()->default_value(
293 0 : g_viz_constants.TtlValuesDefault.find(
294 8 : TtlType::STATSDATA_TTL)->second),
295 : "TTL in hours for analytics statistics data")
296 16 : ("DEFAULT.analytics_flow_ttl",
297 16 : opt::value<uint64_t>()->default_value(
298 0 : g_viz_constants.TtlValuesDefault.find(
299 8 : TtlType::FLOWDATA_TTL)->second),
300 : "TTL in hours for analytics flow data")
301 16 : ("DEFAULT.cassandra_server_list",
302 8 : opt::value<vector<string> >()->default_value(
303 : default_cassandra_server_list, default_cassandra_server),
304 : "Cassandra server list")
305 16 : ("DEFAULT.zookeeper_server_list",
306 16 : opt::value<string>()->default_value(""),
307 : "Zookeeper server list")
308 16 : ("DEFAULT.partitions",
309 8 : opt::value<uint16_t>()->default_value(
310 : default_partitions),
311 : "Number of partitions to use for publishing to kafka")
312 8 : ("DEFAULT.dup", opt::bool_switch(&dup_), "Internal use flag")
313 8 : ("DEFAULT.hostip", opt::value<string>()->default_value(host_ip),
314 : "IP address of collector")
315 8 : ("DEFAULT.hostname", opt::value<string>()->default_value(hostname),
316 : "Hostname of collector")
317 16 : ("DEFAULT.http_server_port",
318 8 : opt::value<uint16_t>()->default_value(default_http_server_port),
319 : "Sandesh HTTP listener port")
320 :
321 8 : ("DEFAULT.log_category", opt::value<string>(),
322 : "Category filter for local logging of sandesh messages")
323 8 : ("DEFAULT.log_disable", opt::bool_switch(&log_disable_),
324 : "Disable sandesh logging")
325 16 : ("DEFAULT.log_file", opt::value<string>()->default_value("<stdout>"),
326 : "Filename for the logs to be written to")
327 16 : ("DEFAULT.log_property_file", opt::value<string>()->default_value(""),
328 : "log4cplus property file name")
329 16 : ("DEFAULT.log_files_count",
330 8 : opt::value<int>()->default_value(10),
331 : "Maximum log file roll over index")
332 16 : ("DEFAULT.log_file_size",
333 8 : opt::value<long>()->default_value(1024*1024),
334 : "Maximum size of the log file")
335 16 : ("DEFAULT.log_level", opt::value<string>()->default_value("SYS_NOTICE"),
336 : "Severity level for local logging of sandesh messages")
337 8 : ("DEFAULT.log_local", opt::bool_switch(&log_local_),
338 : "Enable local logging of sandesh messages")
339 8 : ("DEFAULT.use_syslog", opt::bool_switch(&use_syslog_),
340 : "Enable logging to syslog")
341 16 : ("DEFAULT.syslog_facility", opt::value<string>()->default_value("LOG_LOCAL0"),
342 : "Syslog facility to receive log lines")
343 8 : ("DEFAULT.test_mode", opt::bool_switch(&test_mode_),
344 : "Enable collector to run in test-mode")
345 8 : ("DEFAULT.disable_flow_collection",
346 8 : opt::bool_switch(&disable_flow_collection_),
347 : "Disable flow message collection")
348 : ;
349 :
350 : // Command line and config file options.
351 16 : opt::options_description kafka_config("Kafka Configuration options");
352 8 : kafka_config.add_options()
353 16 : ("KAFKA.kafka_broker_list",
354 16 : opt::value<vector<string> >()->default_value(
355 : default_kafka_broker_list, ""),
356 : "kafka broker list")
357 16 : ("KAFKA.kafka_ssl_enable",
358 8 : opt::value<bool>()->default_value(false),
359 : "Enable SSL Encryptions for Kafka connection")
360 16 : ("KAFKA.kafka_keyfile", opt::value<std::string>()->default_value(
361 : "/etc/contrail/ssl/private/server-privkey.pem"),
362 : "kafka SSL private key")
363 16 : ("KAFKA.kafka_certfile", opt::value<std::string>()->default_value(
364 : "/etc/contrail/ssl/certs/server.pem"),
365 : "kafka SSL certificate")
366 8 : ("KAFKA.kafka_ca_cert", opt::value<std::string>()->default_value(
367 : "/etc/contrail/ssl/certs/ca-cert.pem"),
368 : "Kafka CA SSL certificate")
369 : ;
370 :
371 : // Command line and config file options.
372 16 : opt::options_description redis_config("Redis Configuration options");
373 8 : redis_config.add_options()
374 16 : ("REDIS.port",
375 8 : opt::value<uint16_t>()->default_value(default_redis_port),
376 : "Port of Redis-uve server")
377 16 : ("REDIS.server", opt::value<string>()->default_value("127.0.0.1"),
378 : "IP address of Redis Server")
379 8 : ("REDIS.password", opt::value<string>()->default_value(""),
380 : "password for Redis Server")
381 : ;
382 :
383 : // Command line and config file options.
384 16 : opt::options_description keystone_config("Keystone Configuration options");
385 8 : keystone_config.add_options()
386 16 : ("KEYSTONE.auth_host", opt::value<string>()->default_value("127.0.0.1"),
387 : "IP address of keystone Server")
388 16 : ("KEYSTONE.auth_port",
389 8 : opt::value<uint16_t>()->default_value(default_ks_port),
390 : "Keystone auth server port")
391 16 : ("KEYSTONE.auth_protocol", opt::value<string>()->default_value("http"),
392 : "protocol used to authenticate with Keystone Server")
393 16 : ("KEYSTONE.admin_user", opt::value<string>()->default_value("admin"),
394 : "Keystone username")
395 16 : ("KEYSTONE.admin_password", opt::value<string>()->default_value(
396 : "admin123"), "Keystone password")
397 16 : ("KEYSTONE.admin_tenant_name", opt::value<string>()->default_value(
398 : "tenant"), "Keystone tenant")
399 8 : ("KEYSTONE.insecure", opt::bool_switch(&ks_insecure_),
400 : "keystone using tls")
401 16 : ("KEYSTONE.auth_url", opt::value<string>()->default_value("a.com"),
402 : "keystone auth url")
403 16 : ("KEYSTONE.memcache_servers", opt::value<string>()->default_value(
404 : "127.0.0.1:11211"), "memcache servers")
405 16 : ("KEYSTONE.certfile", opt::value<string>()->default_value(
406 : "/etc/contrail/ks-cert"), "Keystone certificate")
407 16 : ("KEYSTONE.keyfile", opt::value<string>()->default_value(
408 : "/etc/contrail/ks-key"), "Keystone private key")
409 8 : ("KEYSTONE.cafile", opt::value<string>()->default_value(
410 : "/etc/contrail/ks-ca"), "Keystone CA chain")
411 : ;
412 :
413 8 : vector<string> default_config_db_server_list;
414 8 : string default_config_db_server(host_ip + ":9042");
415 8 : default_config_db_server_list.push_back(default_config_db_server);
416 :
417 8 : vector<string> default_rabbitmq_server_list;
418 8 : string default_rabbitmq_server(host_ip + ":5672");
419 8 : default_rabbitmq_server_list.push_back(default_rabbitmq_server);
420 : // configdb_config options.
421 16 : opt::options_description configdb_config("Config database Configuration options");
422 8 : configdb_config.add_options()
423 16 : ("CONFIGDB.config_db_server_list",
424 8 : opt::value<vector<string> >()->default_value(
425 : default_config_db_server_list, default_config_db_server),
426 : "Config database server list")
427 16 : ("CONFIGDB.config_db_username",
428 16 : opt::value<string>()->default_value(""),
429 : "ConfigDB user")
430 16 : ("CONFIGDB.config_db_password",
431 16 : opt::value<string>()->default_value(""),
432 : "ConfigDB password")
433 16 : ("CONFIGDB.config_db_use_ssl",
434 8 : opt::value<bool>()->default_value(false),
435 : "Use SSL for Cassandra connection")
436 16 : ("CONFIGDB.config_db_ca_certs",
437 16 : opt::value<string>()->default_value(""),
438 : "CA Certificate file for SSL Cassandra connection")
439 16 : ("CONFIGDB.rabbitmq_server_list",
440 8 : opt::value<vector<string> >()->default_value(
441 : default_rabbitmq_server_list, default_rabbitmq_server),
442 : "RabbitMQ server list")
443 16 : ("CONFIGDB.rabbitmq_user",
444 16 : opt::value<string>()->default_value("guest"),
445 : "RabbitMQ user")
446 16 : ("CONFIGDB.rabbitmq_password",
447 16 : opt::value<string>()->default_value("guest"),
448 : "RabbitMQ password")
449 16 : ("CONFIGDB.rabbitmq_vhost",
450 16 : opt::value<string>()->default_value(""),
451 : "RabbitMQ vhost")
452 16 : ("CONFIGDB.rabbitmq_use_ssl",
453 8 : opt::value<bool>()->default_value(false),
454 : "Use SSL for RabbitMQ connection")
455 16 : ("CONFIGDB.rabbitmq_ssl_version",
456 16 : opt::value<string>()->default_value(""),
457 : "SSL version for RabbitMQ connection")
458 16 : ("CONFIGDB.rabbitmq_ssl_keyfile",
459 16 : opt::value<string>()->default_value(""),
460 : "Keyfile for SSL RabbitMQ connection")
461 16 : ("CONFIGDB.rabbitmq_ssl_certfile",
462 16 : opt::value<string>()->default_value(""),
463 : "Certificate file for SSL RabbitMQ connection")
464 8 : ("CONFIGDB.rabbitmq_ssl_ca_certs",
465 8 : opt::value<string>()->default_value(""),
466 : "CA Certificate file for SSL RabbitMQ connection")
467 : ;
468 :
469 : // Command line and config file options.
470 16 : opt::options_description sandesh_config("Sandesh Configuration options");
471 8 : sandesh::options::AddOptions(&sandesh_config, &sandesh_config_);
472 :
473 : // Command line and config file options for api-server
474 16 : opt::options_description api_server_config("Api-Server Configuration options");
475 8 : api_server_config.add_options()
476 16 : ("API_SERVER.api_server_list",
477 8 : opt::value<vector<string> >()->default_value(
478 : default_api_server_list, default_api_server),
479 : "Api-Server list")
480 8 : ("API_SERVER.api_server_use_ssl",
481 8 : opt::bool_switch(&api_server_use_ssl_),
482 : "Use ssl for connecting to Api-Server")
483 : ;
484 :
485 8 : config_file_options_.add(config).add(cassandra_config)
486 8 : .add(database_config).add(sandesh_config).add(keystone_config).add(kafka_config)
487 8 : .add(collector_config).add(redis_config).add(api_server_config).add(configdb_config);
488 8 : cmdline_options.add(generic).add(config).add(cassandra_config)
489 8 : .add(database_config).add(sandesh_config).add(keystone_config).add(kafka_config)
490 8 : .add(collector_config).add(redis_config).add(api_server_config).add(configdb_config);
491 8 : }
492 :
493 16 : static bool ValidateCompactionStrategyOption(
494 : const std::string &compaction_strategy,
495 : const std::string &option) {
496 25 : if (!((compaction_strategy ==
497 9 : GenDb::g_gendb_constants.DATE_TIERED_COMPACTION_STRATEGY) ||
498 9 : (compaction_strategy ==
499 8 : GenDb::g_gendb_constants.LEVELED_COMPACTION_STRATEGY) ||
500 8 : (compaction_strategy ==
501 : GenDb::g_gendb_constants.SIZE_TIERED_COMPACTION_STRATEGY) ||
502 0 : (compaction_strategy ==
503 : GenDb::g_gendb_constants.TIME_WINDOW_COMPACTION_STRATEGY))) {
504 : cout << "Invalid " << option << ", please select one of [" <<
505 : GenDb::g_gendb_constants.DATE_TIERED_COMPACTION_STRATEGY << ", " <<
506 : GenDb::g_gendb_constants.LEVELED_COMPACTION_STRATEGY << ", " <<
507 : GenDb::g_gendb_constants.SIZE_TIERED_COMPACTION_STRATEGY << ", " <<
508 0 : GenDb::g_gendb_constants.TIME_WINDOW_COMPACTION_STRATEGY << "]" <<
509 0 : endl;
510 0 : return false;
511 : }
512 16 : return true;
513 : }
514 :
515 24 : uint32_t Options::GenerateHash(const std::vector<std::string> &list) {
516 24 : std::string concat_servers;
517 24 : std::vector<std::string>::const_iterator iter;
518 48 : for (iter = list.begin(); iter != list.end(); iter++) {
519 24 : concat_servers += *iter;
520 : }
521 : boost::hash<std::string> string_hash;
522 48 : return(string_hash(concat_servers));
523 24 : }
524 :
525 8 : uint32_t Options::GenerateHash(const ConfigClientOptions &config) {
526 8 : uint32_t chk_sum = GenerateHash(config.config_db_server_list);
527 8 : chk_sum += GenerateHash(config.rabbitmq_server_list);
528 : boost::hash<std::string> string_hash;
529 8 : chk_sum += string_hash(config.rabbitmq_user);
530 8 : chk_sum += string_hash(config.rabbitmq_password);
531 8 : chk_sum += string_hash(config.config_db_username);
532 8 : chk_sum += string_hash(config.config_db_password);
533 8 : return chk_sum;
534 : }
535 :
536 : // Process command line options. They can come from a conf file as well. Options
537 : // from command line always overrides those that come from the config file.
538 8 : void Options::Process(int argc, char *argv[],
539 : opt::options_description &cmdline_options) {
540 : // Process options off command line first.
541 8 : opt::variables_map var_map;
542 8 : opt::store(opt::parse_command_line(argc, argv, cmdline_options), var_map);
543 : // Process options off configuration file.
544 8 : GetOptValue< vector<string> >(var_map, config_file_,
545 : "conf_file");
546 8 : ifstream config_file_in;
547 24 : for(std::vector<int>::size_type i = 0; i != config_file_.size(); i++) {
548 16 : config_file_in.open(config_file_[i].c_str());
549 16 : if (config_file_in.good()) {
550 8 : opt::store(opt::parse_config_file(config_file_in, config_file_options_, true),
551 : var_map);
552 : }
553 16 : config_file_in.close();
554 : }
555 :
556 8 : opt::notify(var_map);
557 :
558 8 : if (var_map.count("help")) {
559 0 : cout << cmdline_options << endl;
560 0 : exit(0);
561 : }
562 :
563 8 : if (var_map.count("version")) {
564 0 : cout << BuildInfo << endl;
565 0 : exit(0);
566 : }
567 :
568 : // Retrieve the options.
569 8 : GetOptValue<uint16_t>(var_map, collector_port_, "COLLECTOR.port");
570 8 : GetOptValue<string>(var_map, collector_server_, "COLLECTOR.server");
571 16 : GetOptValue<uint32_t>(
572 8 : var_map, db_write_options_.disk_usage_percentage_high_watermark0_,
573 : "DATABASE.disk_usage_percentage.high_watermark0");
574 16 : GetOptValue<uint32_t>(
575 8 : var_map, db_write_options_.disk_usage_percentage_low_watermark0_,
576 : "DATABASE.disk_usage_percentage.low_watermark0");
577 16 : GetOptValue<uint32_t>(
578 8 : var_map, db_write_options_.disk_usage_percentage_high_watermark1_,
579 : "DATABASE.disk_usage_percentage.high_watermark1");
580 16 : GetOptValue<uint32_t>(
581 8 : var_map, db_write_options_.disk_usage_percentage_low_watermark1_,
582 : "DATABASE.disk_usage_percentage.low_watermark1");
583 16 : GetOptValue<uint32_t>(
584 8 : var_map, db_write_options_.disk_usage_percentage_high_watermark2_,
585 : "DATABASE.disk_usage_percentage.high_watermark2");
586 16 : GetOptValue<uint32_t>(
587 8 : var_map, db_write_options_.disk_usage_percentage_low_watermark2_,
588 : "DATABASE.disk_usage_percentage.low_watermark2");
589 16 : GetOptValue<uint32_t>(
590 8 : var_map, db_write_options_.pending_compaction_tasks_high_watermark0_,
591 : "DATABASE.pending_compaction_tasks.high_watermark0");
592 16 : GetOptValue<uint32_t>(
593 8 : var_map, db_write_options_.pending_compaction_tasks_low_watermark0_,
594 : "DATABASE.pending_compaction_tasks.low_watermark0");
595 16 : GetOptValue<uint32_t>(
596 8 : var_map, db_write_options_.pending_compaction_tasks_high_watermark1_,
597 : "DATABASE.pending_compaction_tasks.high_watermark1");
598 16 : GetOptValue<uint32_t>(
599 8 : var_map, db_write_options_.pending_compaction_tasks_low_watermark1_,
600 : "DATABASE.pending_compaction_tasks.low_watermark1");
601 16 : GetOptValue<uint32_t>(
602 8 : var_map, db_write_options_.pending_compaction_tasks_high_watermark2_,
603 : "DATABASE.pending_compaction_tasks.high_watermark2");
604 16 : GetOptValue<uint32_t>(
605 8 : var_map, db_write_options_.pending_compaction_tasks_low_watermark2_,
606 : "DATABASE.pending_compaction_tasks.low_watermark2");
607 :
608 16 : GetOptValue<string>(
609 8 : var_map, db_write_options_.high_watermark0_message_severity_level_,
610 : "DATABASE.high_watermark0.message_severity_level");
611 16 : GetOptValue<string>(
612 8 : var_map, db_write_options_.low_watermark0_message_severity_level_,
613 : "DATABASE.low_watermark0.message_severity_level");
614 16 : GetOptValue<string>(
615 8 : var_map, db_write_options_.high_watermark1_message_severity_level_,
616 : "DATABASE.high_watermark1.message_severity_level");
617 16 : GetOptValue<string>(
618 8 : var_map, db_write_options_.low_watermark1_message_severity_level_,
619 : "DATABASE.low_watermark1.message_severity_level");
620 16 : GetOptValue<string>(
621 8 : var_map, db_write_options_.high_watermark2_message_severity_level_,
622 : "DATABASE.high_watermark2.message_severity_level");
623 16 : GetOptValue<string>(
624 8 : var_map, db_write_options_.low_watermark2_message_severity_level_,
625 : "DATABASE.low_watermark2.message_severity_level");
626 :
627 8 : if (GetOptValueIfNotDefaulted<uint16_t>(var_map, collector_structured_syslog_port_,
628 : "STRUCTURED_SYSLOG_COLLECTOR.port")) {
629 2 : collector_structured_syslog_port_configured_ = true;
630 : } else {
631 6 : collector_structured_syslog_port_configured_ = false;
632 : }
633 8 : GetOptValue< vector<string> >(var_map, collector_structured_syslog_tcp_forward_destination_,
634 : "STRUCTURED_SYSLOG_COLLECTOR.tcp_forward_destination");
635 :
636 8 : GetOptValue< vector<string> >(var_map, collector_structured_syslog_kafka_broker_list_,
637 : "STRUCTURED_SYSLOG_COLLECTOR.kafka_broker_list");
638 :
639 8 : GetOptValue<string>(var_map, collector_structured_syslog_kafka_topic_,
640 : "STRUCTURED_SYSLOG_COLLECTOR.kafka_topic");
641 :
642 8 : GetOptValue<uint16_t>(var_map, collector_structured_syslog_kafka_partitions_,
643 : "STRUCTURED_SYSLOG_COLLECTOR.kafka_partitions");
644 :
645 8 : GetOptValue<uint64_t>(var_map, collector_structured_syslog_active_session_map_limit_,
646 : "STRUCTURED_SYSLOG_COLLECTOR.active_session_map_limit");
647 :
648 8 : GetOptValue<uint64_t>(var_map, analytics_data_ttl_,
649 : "DEFAULT.analytics_data_ttl");
650 8 : if (analytics_data_ttl_ == (uint64_t)-1) {
651 0 : analytics_data_ttl_ = g_viz_constants.TtlValuesDefault.find(TtlType::GLOBAL_TTL)->second;
652 : }
653 8 : GetOptValue<uint64_t>(var_map, analytics_config_audit_ttl_,
654 : "DEFAULT.analytics_config_audit_ttl");
655 8 : if (analytics_config_audit_ttl_ == (uint64_t)-1) {
656 0 : analytics_config_audit_ttl_ = g_viz_constants.TtlValuesDefault.find(TtlType::CONFIGAUDIT_TTL)->second;
657 : }
658 8 : GetOptValue<uint64_t>(var_map, analytics_statistics_ttl_,
659 : "DEFAULT.analytics_statistics_ttl");
660 8 : if (analytics_statistics_ttl_ == (uint64_t)-1) {
661 0 : analytics_statistics_ttl_ = g_viz_constants.TtlValuesDefault.find(TtlType::STATSDATA_TTL)->second;
662 : }
663 8 : GetOptValue<uint64_t>(var_map, analytics_flow_ttl_,
664 : "DEFAULT.analytics_flow_ttl");
665 8 : if (analytics_flow_ttl_ == (uint64_t)-1) {
666 0 : analytics_flow_ttl_ = g_viz_constants.TtlValuesDefault.find(TtlType::FLOWDATA_TTL)->second;
667 : }
668 :
669 8 : GetOptValue< vector<string> >(var_map, cassandra_server_list_,
670 : "DEFAULT.cassandra_server_list");
671 8 : GetOptValue<string>(var_map, zookeeper_server_list_,
672 : "DEFAULT.zookeeper_server_list");
673 8 : GetOptValue< vector<string> >(var_map, kafka_broker_list_,
674 : "KAFKA.kafka_broker_list");
675 8 : GetOptValue<uint16_t>(var_map, partitions_, "DEFAULT.partitions");
676 8 : GetOptValue<string>(var_map, host_ip_, "DEFAULT.hostip");
677 8 : GetOptValue<string>(var_map, hostname_, "DEFAULT.hostname");
678 8 : GetOptValue<uint16_t>(var_map, http_server_port_,
679 : "DEFAULT.http_server_port");
680 :
681 8 : GetOptValue<string>(var_map, log_category_, "DEFAULT.log_category");
682 8 : GetOptValue<string>(var_map, log_file_, "DEFAULT.log_file");
683 8 : GetOptValue<string>(var_map, log_property_file_, "DEFAULT.log_property_file");
684 8 : GetOptValue<int>(var_map, log_files_count_, "DEFAULT.log_files_count");
685 8 : GetOptValue<long>(var_map, log_file_size_, "DEFAULT.log_file_size");
686 8 : GetOptValue<string>(var_map, log_level_, "DEFAULT.log_level");
687 8 : GetOptValue<bool>(var_map, use_syslog_, "DEFAULT.use_syslog");
688 8 : GetOptValue<string>(var_map, syslog_facility_, "DEFAULT.syslog_facility");
689 8 : GetOptValue<string>(var_map, kafka_prefix_, "DATABASE.cluster_id");
690 8 : GetOptValue<bool>(var_map, kafka_options_.ssl_enable, "KAFKA.kafka_ssl_enable");
691 8 : GetOptValue<string>(var_map, kafka_options_.keyfile, "KAFKA.kafka_keyfile");
692 8 : GetOptValue<string>(var_map, kafka_options_.certfile, "KAFKA.kafka_certfile");
693 8 : GetOptValue<string>(var_map, kafka_options_.ca_cert, "KAFKA.kafka_ca_cert");
694 8 : GetOptValue<uint16_t>(var_map, redis_port_, "REDIS.port");
695 8 : GetOptValue<string>(var_map, redis_server_, "REDIS.server");
696 8 : GetOptValue<string>(var_map, redis_password_, "REDIS.password");
697 :
698 8 : GetOptValue<string>(var_map, cassandra_options_.cluster_id_, "DATABASE.cluster_id");
699 :
700 8 : GetOptValue<string>(var_map, cassandra_options_.user_,
701 : "CASSANDRA.cassandra_user");
702 8 : GetOptValue<string>(var_map, cassandra_options_.password_,
703 : "CASSANDRA.cassandra_password");
704 8 : GetOptValue<bool>(var_map, cassandra_options_.use_ssl_,
705 : "CASSANDRA.cassandra_use_ssl");
706 8 : GetOptValue<string>(var_map, cassandra_options_.ca_certs_,
707 : "CASSANDRA.cassandra_ca_certs");
708 8 : GetOptValue<string>(var_map, cassandra_options_.compaction_strategy_,
709 : "CASSANDRA.compaction_strategy");
710 8 : GetOptValue<string>(var_map, cassandra_options_.replication_factor_,
711 : "CASSANDRA.replication_factor");
712 16 : if (!ValidateCompactionStrategyOption(
713 8 : cassandra_options_.compaction_strategy_,
714 : "CASSANDRA.compaction_strategy")) {
715 0 : exit(-1);
716 : }
717 16 : GetOptValue<string>(var_map,
718 8 : cassandra_options_.flow_tables_compaction_strategy_,
719 : "CASSANDRA.flow_tables.compaction_strategy");
720 16 : if (!ValidateCompactionStrategyOption(
721 8 : cassandra_options_.flow_tables_compaction_strategy_,
722 : "CASSANDRA.flow_tables.compaction_strategy")) {
723 0 : exit(-1);
724 : }
725 8 : GetOptValue<uint16_t>(var_map, ks_port_, "KEYSTONE.auth_port");
726 8 : GetOptValue<string>(var_map, ks_server_, "KEYSTONE.auth_host");
727 8 : GetOptValue<string>(var_map, ks_protocol_, "KEYSTONE.auth_protocol");
728 8 : GetOptValue<string>(var_map, ks_user_, "KEYSTONE.admin_user");
729 8 : GetOptValue<string>(var_map, ks_password_, "KEYSTONE.admin_password");
730 8 : GetOptValue<string>(var_map, ks_tenant_, "KEYSTONE.admin_tenant_name");
731 8 : GetOptValue<string>(var_map, ks_authurl_, "KEYSTONE.auth_url");
732 8 : GetOptValue<string>(var_map, memcache_servers_, "KEYSTONE.memcache_servers");
733 8 : GetOptValue<string>(var_map, ks_cert_, "KEYSTONE.certfile");
734 8 : GetOptValue<string>(var_map, ks_key_, "KEYSTONE.keyfile");
735 8 : GetOptValue<string>(var_map, ks_ca_, "KEYSTONE.cafile");
736 :
737 8 : sandesh::options::ProcessOptions(var_map, &sandesh_config_);
738 :
739 8 : GetOptValue< vector<string> >(var_map, api_server_list_,
740 : "API_SERVER.api_server_list");
741 8 : api_server_checksum_ = GenerateHash(api_server_list_);
742 8 : std::random_shuffle(api_server_list_.begin(), api_server_list_.end());
743 :
744 8 : GetOptValue<bool>(var_map, api_server_use_ssl_,
745 : "API_SERVER.api_server_use_ssl");
746 8 : ParseConfigOptions(var_map);
747 8 : }
748 :
749 0 : void Options::ParseReConfig() {
750 : // ReParse the filtered config params
751 0 : opt::variables_map var_map;
752 0 : ifstream config_file_in;
753 0 : for(std::vector<int>::size_type i = 0; i != config_file_.size(); i++) {
754 0 : config_file_in.open(config_file_[i].c_str());
755 0 : if (config_file_in.good()) {
756 0 : opt::store(opt::parse_config_file(config_file_in,
757 0 : config_file_options_, true), var_map);
758 : }
759 0 : config_file_in.close();
760 : }
761 0 : api_server_list_.clear();
762 0 : GetOptValue< vector<string> >(var_map, api_server_list_,
763 : "API_SERVER.api_server_list");
764 0 : uint32_t new_checksum = GenerateHash(api_server_list_);
765 0 : if (api_server_checksum_ != new_checksum) {
766 0 : api_server_checksum_ = new_checksum;
767 0 : std::random_shuffle(api_server_list_.begin(),
768 : api_server_list_.end());
769 : }
770 :
771 0 : uint32_t old_config_chksum = configdb_chksum_;
772 0 : ParseConfigOptions(var_map);
773 0 : if ((old_config_chksum != configdb_chksum_) && config_client_manager_) {
774 0 : config_client_manager_->ReinitConfigClient(configdb_options());
775 : }
776 0 : }
777 :
778 8 : void Options::ParseConfigOptions(const boost::program_options::variables_map
779 : &var_map) {
780 8 : configdb_options_.config_db_server_list.clear();
781 16 : GetOptValue< vector<string> >(var_map,
782 8 : configdb_options_.config_db_server_list,
783 : "CONFIGDB.config_db_server_list");
784 16 : GetOptValue<string>(var_map,
785 8 : configdb_options_.config_db_username,
786 : "CONFIGDB.config_db_username");
787 16 : GetOptValue<string>(var_map,
788 8 : configdb_options_.config_db_password,
789 : "CONFIGDB.config_db_password");
790 16 : GetOptValue<bool>(var_map,
791 8 : configdb_options_.config_db_use_ssl,
792 : "CONFIGDB.config_db_use_ssl");
793 16 : GetOptValue<string>(var_map,
794 8 : configdb_options_.config_db_ca_certs,
795 : "CONFIGDB.config_db_ca_certs");
796 8 : configdb_options_.rabbitmq_server_list.clear();
797 16 : GetOptValue< vector<string> >(var_map,
798 8 : configdb_options_.rabbitmq_server_list,
799 : "CONFIGDB.rabbitmq_server_list");
800 16 : GetOptValue<string>(var_map,
801 8 : configdb_options_.rabbitmq_user,
802 : "CONFIGDB.rabbitmq_user");
803 16 : GetOptValue<string>(var_map,
804 8 : configdb_options_.rabbitmq_password,
805 : "CONFIGDB.rabbitmq_password");
806 16 : GetOptValue<string>(var_map,
807 8 : configdb_options_.rabbitmq_vhost,
808 : "CONFIGDB.rabbitmq_vhost");
809 16 : GetOptValue<bool>(var_map,
810 8 : configdb_options_.rabbitmq_use_ssl,
811 : "CONFIGDB.rabbitmq_use_ssl");
812 16 : GetOptValue<string>(var_map,
813 8 : configdb_options_.rabbitmq_ssl_version,
814 : "CONFIGDB.rabbitmq_ssl_version");
815 16 : GetOptValue<string>(var_map,
816 8 : configdb_options_.rabbitmq_ssl_keyfile,
817 : "CONFIGDB.rabbitmq_ssl_keyfile");
818 16 : GetOptValue<string>(var_map,
819 8 : configdb_options_.rabbitmq_ssl_certfile,
820 : "CONFIGDB.rabbitmq_ssl_certfile");
821 16 : GetOptValue<string>(var_map,
822 8 : configdb_options_.rabbitmq_ssl_ca_certs,
823 : "CONFIGDB.rabbitmq_ssl_ca_certs");
824 8 : configdb_chksum_ = GenerateHash(configdb_options_);
825 8 : }
|
