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