const char *os_config_read_string(const char *section, const char *name, const char *default_value)
{
Profile *p = profile_read(Osreg_config_file_name);
#ifdef WIN32
if (p == nullptr) {
// No config file, fall back to registy
return registry_read_string(section, name, default_value);
}
#endif
nprintf(("Registry", "os_config_read_string(): section = \"%s\", name = \"%s\", default value: \"%s\"\n",
(section) ? section : DEFAULT_SECTION, name, (default_value) ? default_value : NOX("NULL")));
if (section == NULL)
section = DEFAULT_SECTION;
char *ptr = profile_get_value(p, section, name);
if (ptr != NULL) {
strncpy(tmp_string_data, ptr, 1023);
default_value = tmp_string_data;
}
profile_free(p);
return default_value;
}
QString ProfileControl::clockAlarmToneFile()
{
if (m_clockAlarmToneFile.isNull()) {
m_clockAlarmToneFile = QString::fromUtf8(profile_get_value(GeneralProfile, ClockAlarmToneKey));
}
return m_clockAlarmToneFile;
}
QString ProfileControl::internetCallToneFile()
{
if (m_internetCallToneFile.isNull()) {
m_internetCallToneFile = QString::fromUtf8(profile_get_value(GeneralProfile, InternetCallToneKey));
}
return m_internetCallToneFile;
}
QString ProfileControl::mailToneFile()
{
if (m_mailToneFile.isNull()) {
m_mailToneFile = QString::fromUtf8(profile_get_value(GeneralProfile, MailToneKey));
}
return m_mailToneFile;
}
unsigned int os_config_read_uint(const char *section, const char *name, unsigned int default_value)
{
Profile *p = profile_read(Osreg_config_file_name);
#ifdef WIN32
if (p == nullptr) {
// No config file, fall back to registy
return registry_read_uint(section, name, default_value);
}
#endif
if (section == NULL)
section = DEFAULT_SECTION;
char *ptr = profile_get_value(p, section, name);
if (ptr != NULL) {
default_value = atoi(ptr);
}
profile_free(p);
return default_value;
}
int main(int argc, char **argv)
{
swss::Logger::getInstance().setMinPrio(swss::Logger::SWSS_DEBUG);
SWSS_LOG_ENTER();
auto options = handleCmdLine(argc, argv);
handleProfileMap(options.profileMapFile);
swss::DBConnector *db = new swss::DBConnector(ASIC_DB, "localhost", 6379, 0);
swss::DBConnector *dbNtf = new swss::DBConnector(ASIC_DB, "localhost", 6379, 0);
g_redisClient = new swss::RedisClient(db);
updateLogLevel();
swss::ConsumerTable *asicState = new swss::ConsumerTable(db, "ASIC_STATE");
swss::NotificationConsumer *notifySyncdQuery = new swss::NotificationConsumer(db, "NOTIFYSYNCDREQUERY");
swss::NotificationConsumer *restartQuery = new swss::NotificationConsumer(db, "RESTARTQUERY");
// at the end we cant use producer consumer concept since
// if one proces will restart there may be something in the queue
// also "remove" from response queue will also trigger another "response"
getRequest = new swss::ConsumerTable(db, "GETREQUEST");
getResponse = new swss::ProducerTable(db, "GETRESPONSE");
notifications = new swss::NotificationProducer(dbNtf, "NOTIFICATIONS");
notifySyncdResponse = new swss::NotificationProducer(db, "NOTIFYSYNCDRESPONSE");
#ifdef MLNXSAI
/* This file is included in Mellanox SAI package. */
std::string mlnx_config_file = "/usr/share/sai_2700.xml";
gProfileMap[SAI_KEY_INIT_CONFIG_FILE] = mlnx_config_file;
#endif /* MLNX_SAI */
g_veryFirstRun = isVeryFirstRun();
if (options.warmStart)
{
const char *warmBootReadFile = profile_get_value(0, SAI_KEY_WARM_BOOT_READ_FILE);
SWSS_LOG_NOTICE("using warmBootReadFile: '%s'", warmBootReadFile);
if (warmBootReadFile == NULL || access(warmBootReadFile, F_OK) == -1)
{
SWSS_LOG_WARN("user requested warmStart but warmBootReadFile is not specified or not accesible, forcing cold start");
options.warmStart = false;
}
}
if (options.warmStart && g_veryFirstRun)
{
SWSS_LOG_WARN("warm start requested, but this is very first syncd start, forcing cold start");
// we force cold start since if it's first run then redis db is not complete
// so redis asic view will not reflect warm boot asic state, if this happen
// then orch agent needs to be restarted as well to repopulate asic view
options.warmStart = false;
}
// gProfileMap[SAI_KEY_WARM_BOOT] = options.warmStart ? "1" : "0";
sai_api_initialize(0, (service_method_table_t*)&test_services);
populate_sai_apis();
initialize_common_api_pointers();
sai_status_t status = sai_switch_api->initialize_switch(0, "0xb850", "", &switch_notifications);
if (status != SAI_STATUS_SUCCESS)
{
SWSS_LOG_ERROR("fail to sai_initialize_switch: %d", status);
exit(EXIT_FAILURE);
}
#ifdef BRCMSAI
if (options.diagShell)
{
SWSS_LOG_NOTICE("starting bcm diag shell thread");
std::thread bcm_diag_shell_thread = std::thread(sai_diag_shell);
bcm_diag_shell_thread.detach();
}
#endif /* BRCMSAI */
SWSS_LOG_NOTICE("syncd started");
bool warmRestartHint = false;
try
{
onSyncdStart(options.warmStart);
if (options.disableCountersThread == false)
{
SWSS_LOG_NOTICE("starting counters thread");
startCountersThread(options.countersThreadIntervalInSeconds);
}
SWSS_LOG_NOTICE("syncd listening for events");
swss::Select s;
s.addSelectable(getRequest);
s.addSelectable(asicState);
s.addSelectable(notifySyncdQuery);
s.addSelectable(restartQuery);
while(true)
{
swss::Selectable *sel;
int fd;
int result = s.select(&sel, &fd);
if (sel == restartQuery)
{
warmRestartHint = handleRestartQuery(*restartQuery);
break;
}
if (sel == notifySyncdQuery)
{
notifySyncd(*notifySyncdQuery);
continue;
}
if (result == swss::Select::OBJECT)
{
processEvent(*(swss::ConsumerTable*)sel);
}
}
}
catch(const std::exception &e)
{
SWSS_LOG_ERROR("Runtime error: %s", e.what());
exit(EXIT_FAILURE);
}
endCountersThread();
if (warmRestartHint)
{
const char *warmBootWriteFile = profile_get_value(0, SAI_KEY_WARM_BOOT_WRITE_FILE);
SWSS_LOG_NOTICE("using warmBootWriteFile: '%s'", warmBootWriteFile);
if (warmBootWriteFile == NULL)
{
SWSS_LOG_WARN("user requested warm shutdown but warmBootWriteFile is not specified, forcing cold shutdown");
warmRestartHint = false;
}
}
sai_switch_api->shutdown_switch(warmRestartHint);
SWSS_LOG_NOTICE("calling api uninitialize");
sai_api_uninitialize();
SWSS_LOG_NOTICE("uninitialize finished");
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
int opt;
char *p,*k,*v,**w;
while( (opt = getopt(argc, argv, "hp:s:d:g:t:TlkvV:B:I:D:G:rR:")) != -1 )
{
switch (opt)
{
case 'h':
write(STDOUT_FILENO, usage, sizeof usage - 1);
exit(0);
case 'p':
profile_set_profile(optarg);
break;
case 'l':
p = profile_get_profile();
w = profile_get_profiles();
for( size_t i = 0; w && w[i]; ++i )
{
printf("%s%s\n", w[i], strcmp(w[i],p) ? "" : "*");
}
profile_free_profiles(w);
free(p);
break;
case 'k':
w = profile_get_keys();
for( size_t i = 0; w && w[i]; ++i )
{
printf("%s\n", w[i]);
}
profile_free_keys(w);
break;
case 'r':
w = profile_get_keys();
for( size_t i = 0; w && w[i]; ++i )
{
profile_set_value(0, w[i], "");
}
profile_free_keys(w);
break;
case 'R':
w = profile_get_keys();
for( size_t i = 0; w && w[i]; ++i )
{
profile_set_value(optarg, w[i], "");
}
profile_free_keys(w);
break;
case 'v':
case 'V':
{
p = (opt == 'v') ? 0 : optarg;
profileval_t *t = profile_get_values(p);
for( size_t i = 0; t && t[i].pv_key; ++i )
{
printf("%s = %s (%s)\n", t[i].pv_key, t[i].pv_val, t[i].pv_type);
}
profile_free_values(t);
}
break;
case 'T':
exit(track());
case 's':
parse(optarg, &p,&k,&v);
profile_set_value(p, k, v);
break;
case 'd':
parse(optarg, &p,&k,&v);
profile_set_value(p, k, "");
break;
case 'g':
parse(optarg, &p,&k,&v);
v = profile_get_value(p,k);
printf("%s\n", v);
free(v);
break;
case 'G':
{
parse(optarg, &p,&k,&v);
char *s = profile_get_value(p,k);
printf("STRING: '%s'\n", s);
free(s);
int b = profile_get_value_as_bool(p,k);
printf("BOOL: %s (%d)\n", b ? "On" : "Off", b);
int i = profile_get_value_as_int(p,k);
printf("INT: %d\n", i);
double d = profile_get_value_as_double(p,k);
printf("DOUBLE:%g\n", d);
}
break;
case 'B':
{
parse(optarg, &p,&k,&v);
int v = profile_get_value_as_bool(p,k);
printf("BOOL:%s (%d)\n", v ? "On" : "Off", v);
}
break;
case 'I':
{
parse(optarg, &p,&k,&v);
int v = profile_get_value_as_int(p,k);
printf("INT:%d\n", v);
}
break;
case 'D':
{
parse(optarg, &p,&k,&v);
double v = profile_get_value_as_double(p,k);
printf("DOUBLE:%g\n", v);
}
break;
case 't':
v = profile_get_type(optarg);
printf("%s\n", v);
free(v);
break;
default: /* '?' */
fprintf(stderr, "(use -h for usage info)\n");
exit(EXIT_FAILURE);
}
}
return 0;
}
