int
ErrorReporter::get_trace_no(){
FILE *stream;
unsigned int traceFileNo;
char *file_name= NdbConfig_NextTraceFileName(globalData.ownId);
NdbAutoPtr<char> tmp_aptr(file_name);
/*
* Read last number from tracefile
*/
stream = fopen(file_name, "r+");
if (stream == NULL){
traceFileNo = 1;
} else {
char buf[255];
fgets(buf, 255, stream);
const int scan = sscanf(buf, "%u", &traceFileNo);
if(scan != 1){
traceFileNo = 1;
}
fclose(stream);
traceFileNo++;
}
/**
* Wrap tracefile no
*/
Uint32 tmp = globalEmulatorData.theConfiguration->maxNoOfErrorLogs();
if (traceFileNo > tmp ) {
traceFileNo = 1;
}
/**
* Save new number to the file
*/
stream = fopen(file_name, "w");
if(stream != NULL){
fprintf(stream, "%u", traceFileNo);
fclose(stream);
}
return traceFileNo;
}
int
HostMatch::eval(const Iter& iter)
{
const char* valc;
if(iter.get(m_key, &valc) == 0)
{
struct hostent *h1, *h2, copy1;
char *addr1;
h1 = gethostbyname(m_value.c_str());
if (h1 == NULL) {
return 0;
}
// gethostbyname returns a pointer to a static structure
// so we need to copy the results before doing the next call
memcpy(©1, h1, sizeof(struct hostent));
addr1 = (char *)malloc(copy1.h_length);
NdbAutoPtr<char> tmp_aptr(addr1);
memcpy(addr1, h1->h_addr, copy1.h_length);
h2 = gethostbyname(valc);
if (h2 == NULL) {
return 0;
}
if (copy1.h_addrtype != h2->h_addrtype) {
return 0;
}
if (copy1.h_length != h2->h_length)
{
return 0;
}
return 0 == memcmp(addr1, h2->h_addr, copy1.h_length);
}
return 0;
}
bool
LocalConfig::parseString(const char * connectString, BaseString &err){
char * for_strtok;
char * copy = strdup(connectString);
NdbAutoPtr<char> tmp_aptr(copy);
for (char *tok = strtok_r(copy,";,",&for_strtok); tok != 0;
tok = strtok_r(NULL, ";,", &for_strtok)) {
if (tok[0] == '#') continue;
if (!_ownNodeId) // only one nodeid definition allowed
if (parseNodeId(tok))
continue;
if (parseHostName(tok))
continue;
if (parseFileName(tok))
continue;
err.assfmt("Unexpected entry: \"%s\"", tok);
return false;
}
return true;
}
bool
LocalConfig::init(const char *connectString,
const char *fileName)
{
DBUG_ENTER("LocalConfig::init");
/**
* Escalation:
* 1. Check connectString
* 2. Check given filename
* 3. Check environment variable NDB_CONNECTSTRING
* 4. Check Ndb.cfg in NDB_HOME
* 5. Check Ndb.cfg in cwd
* 6. Check defaultConnectString
*/
_ownNodeId= 0;
//1. Check connectString
if(connectString != 0 && connectString[0] != 0){
if(readConnectString(connectString, "connect string")){
if (ids.size())
DBUG_RETURN(true);
// only nodeid given, continue to find hosts
} else
DBUG_RETURN(false);
}
//2. Check given filename
if (fileName && strlen(fileName) > 0) {
bool fopenError;
if(readFile(fileName, fopenError)){
DBUG_RETURN(true);
}
DBUG_RETURN(false);
}
//3. Check environment variable
char buf[255];
if(NdbEnv_GetEnv("NDB_CONNECTSTRING", buf, sizeof(buf)) &&
strlen(buf) != 0){
if(readConnectString(buf, "NDB_CONNECTSTRING")){
DBUG_RETURN(true);
}
DBUG_RETURN(false);
}
//4. Check Ndb.cfg in NDB_HOME
{
bool fopenError;
char *buf2= NdbConfig_NdbCfgName(1 /*true*/);
NdbAutoPtr<char> tmp_aptr(buf2);
if(readFile(buf2, fopenError))
DBUG_RETURN(true);
if (!fopenError)
DBUG_RETURN(false);
}
//5. Check Ndb.cfg in cwd
{
bool fopenError;
char *buf2= NdbConfig_NdbCfgName(0 /*false*/);
NdbAutoPtr<char> tmp_aptr(buf2);
if(readFile(buf2, fopenError))
DBUG_RETURN(true);
if (!fopenError)
DBUG_RETURN(false);
}
//7. Check
{
char buf2[256];
BaseString::snprintf(buf2, sizeof(buf2), "host=localhost:%s", NDB_PORT);
if(readConnectString(buf2, "default connect string"))
DBUG_RETURN(true);
}
setError(0, "");
DBUG_RETURN(false);
}
void
ndbd_run(bool foreground, int report_fd,
const char* connect_str, int force_nodeid, const char* bind_address,
bool no_start, bool initial, bool initialstart,
unsigned allocated_nodeid)
{
#ifdef _WIN32
{
char shutdown_event_name[32];
_snprintf(shutdown_event_name, sizeof(shutdown_event_name),
"ndbd_shutdown_%d", GetCurrentProcessId());
g_shutdown_event = CreateEvent(NULL, TRUE, FALSE, shutdown_event_name);
if (g_shutdown_event == NULL)
{
g_eventLogger->error("Failed to create shutdown event, error: %d",
GetLastError());
ndbd_exit(1);
}
HANDLE thread = CreateThread(NULL, 0, &shutdown_thread, NULL, 0, NULL);
if (thread == NULL)
{
g_eventLogger->error("couldn't start shutdown thread, error: %d",
GetLastError());
ndbd_exit(1);
}
}
#endif
if (foreground)
g_eventLogger->info("Ndb started in foreground");
if (report_fd)
{
g_eventLogger->debug("Opening report stream on fd: %d", report_fd);
// Open a stream for sending extra status to angel
if (!(angel_info_w = fdopen(report_fd, "w")))
{
g_eventLogger->error("Failed to open stream for reporting "
"to angel, error: %d (%s)", errno, strerror(errno));
ndbd_exit(-1);
}
}
else
{
// No reporting requested, open /dev/null
const char* dev_null = IF_WIN("nul", "/dev/null");
if (!(angel_info_w = fopen(dev_null, "w")))
{
g_eventLogger->error("Failed to open stream for reporting to "
"'%s', error: %d (%s)", dev_null, errno,
strerror(errno));
ndbd_exit(-1);
}
}
globalEmulatorData.create();
Configuration* theConfig = globalEmulatorData.theConfiguration;
if(!theConfig->init(no_start, initial, initialstart))
{
g_eventLogger->error("Failed to init Configuration");
ndbd_exit(-1);
}
theConfig->fetch_configuration(connect_str, force_nodeid, bind_address,
allocated_nodeid);
if (NdbDir::chdir(NdbConfig_get_path(NULL)) != 0)
{
g_eventLogger->warning("Cannot change directory to '%s', error: %d",
NdbConfig_get_path(NULL), errno);
// Ignore error
}
theConfig->setupConfiguration();
if (get_multithreaded_config(globalEmulatorData))
ndbd_exit(-1);
systemInfo(* theConfig, * theConfig->m_logLevel);
NdbThread* pWatchdog = globalEmulatorData.theWatchDog->doStart();
{
/*
* Memory allocation can take a long time for large memory.
*
* So we want the watchdog to monitor the process of initial allocation.
*/
Uint32 watchCounter;
watchCounter = 9; // Means "doing allocation"
globalEmulatorData.theWatchDog->registerWatchedThread(&watchCounter, 0);
if (init_global_memory_manager(globalEmulatorData, &watchCounter))
ndbd_exit(1);
globalEmulatorData.theWatchDog->unregisterWatchedThread(0);
}
globalEmulatorData.theThreadConfig->init();
#ifdef VM_TRACE
// Create a signal logger before block constructors
char *buf= NdbConfig_SignalLogFileName(globalData.ownId);
NdbAutoPtr<char> tmp_aptr(buf);
FILE * signalLog = fopen(buf, "a");
globalSignalLoggers.setOwnNodeId(globalData.ownId);
globalSignalLoggers.setOutputStream(signalLog);
#if 1 // to log startup
{ const char* p = NdbEnv_GetEnv("NDB_SIGNAL_LOG", (char*)0, 0);
if (p != 0) {
char buf[200];
BaseString::snprintf(buf, sizeof(buf), "BLOCK=%s", p);
for (char* q = buf; *q != 0; q++) *q = toupper(toascii(*q));
globalSignalLoggers.log(SignalLoggerManager::LogInOut, buf);
globalData.testOn = 1;
assert(signalLog != 0);
fprintf(signalLog, "START\n");
fflush(signalLog);
}
}
#endif
#endif
// Load blocks (both main and workers)
globalEmulatorData.theSimBlockList->load(globalEmulatorData);
// Set thread concurrency for Solaris' light weight processes
int status;
status = NdbThread_SetConcurrencyLevel(30);
assert(status == 0);
catchsigs(foreground);
/**
* Do startup
*/
switch(globalData.theRestartFlag){
case initial_state:
globalEmulatorData.theThreadConfig->doStart(NodeState::SL_CMVMI);
break;
case perform_start:
globalEmulatorData.theThreadConfig->doStart(NodeState::SL_CMVMI);
globalEmulatorData.theThreadConfig->doStart(NodeState::SL_STARTING);
break;
default:
assert("Illegal state globalData.theRestartFlag" == 0);
}
globalTransporterRegistry.startSending();
globalTransporterRegistry.startReceiving();
if (!globalTransporterRegistry.start_service(*globalEmulatorData.m_socket_server)){
ndbout_c("globalTransporterRegistry.start_service() failed");
ndbd_exit(-1);
}
// Re-use the mgm handle as a transporter
if(!globalTransporterRegistry.connect_client(
theConfig->get_config_retriever()->get_mgmHandlePtr()))
ERROR_SET(fatal, NDBD_EXIT_CONNECTION_SETUP_FAILED,
"Failed to convert mgm connection to a transporter",
__FILE__);
NdbThread* pTrp = globalTransporterRegistry.start_clients();
if (pTrp == 0)
{
ndbout_c("globalTransporterRegistry.start_clients() failed");
ndbd_exit(-1);
}
NdbThread* pSockServ = globalEmulatorData.m_socket_server->startServer();
globalEmulatorData.theConfiguration->addThread(pTrp, SocketClientThread);
globalEmulatorData.theConfiguration->addThread(pWatchdog, WatchDogThread);
globalEmulatorData.theConfiguration->addThread(pSockServ, SocketServerThread);
// theConfig->closeConfiguration();
{
NdbThread *pThis = NdbThread_CreateObject(0);
Uint32 inx = globalEmulatorData.theConfiguration->addThread(pThis,
MainThread);
globalEmulatorData.theThreadConfig->ipControlLoop(pThis, inx);
globalEmulatorData.theConfiguration->removeThreadId(inx);
}
NdbShutdown(0, NST_Normal);
ndbd_exit(0);
}