ListEm::ListEm(QWidget *parent) : QMainWindow(parent) { m_listEmWrapper = new ListEmWrapper(this); m_storage = createListStorage(); m_logger = createLogger(); setupUI(m_storage, m_logger); QTimer::singleShot(100, this, SLOT(checkDatabase())); }
int test_logger(int argc, char *argv[]) { PKIX_Logger *logger, *logger2; PKIX_UInt32 actualMinorVersion; PKIX_UInt32 j = 0; PKIX_TEST_STD_VARS(); startTests("Loggers"); PKIX_TEST_EXPECT_NO_ERROR( PKIX_PL_NssContext_Create(0, PKIX_FALSE, NULL, &plContext)); subTest("PKIX_Logger_Create"); createLogger(&logger, NULL, testLoggerCallback); createLogger(&logger2, (PKIX_PL_Object *)logger, testLoggerCallback2); subTest("Logger Context and Callback"); testContextCallback(logger, logger2); subTest("Logger Component"); testComponent(logger); subTest("Logger MaxLoggingLevel"); testMaxLoggingLevel(logger); subTest("Logger List operations"); testLogger(logger, logger2); subTest("PKIX_Logger_Destroy"); testDestroy(logger); testDestroy(logger2); cleanup: PKIX_Shutdown(plContext); PKIX_TEST_RETURN(); endTests("Loggers"); return (0); }
void ChannelServer::loadLogConfig() { ConfigFile conf("conf/logger.lua", false); initializeLoggingConstants(conf); conf.execute(); bool enabled = conf.getBool("log_channels"); if (enabled) { LogConfig log = conf.getLogConfig("channel"); createLogger(log); } }
int main() { static const int SERVER_PORT = 7892; char in_buffer[1024]; struct sockaddr_in serverAddr; struct sockaddr_storage serverStorage; socklen_t addr_size; serverLogger = createLogger(__FILE__, LOG_LEVEL); // set up socket, call to socket returns a file descriptor (fd) welcomeSocket = socket(AF_INET, SOCK_STREAM, 0); signal(SIGINT, intHandler); createSockaddr_in(&serverAddr, SERVER_PORT, "127.0.0.1"); int bindStatus = bind(welcomeSocket, (struct sockaddr *) &serverAddr, sizeof(serverAddr)); if (bindStatus != 0) { printf("bind error: %s\n", strerror(errno)); cLog("bind error"); exit(0); } do { memset(in_buffer, 0, 1024); // max 5 connections... however only prints "Error!" if hits the limit int listenWelcomeSocket = listen(welcomeSocket, 5); //if(listen(welcomeSocket, 5) == 0) { if(listenWelcomeSocket == 0) { cLog("Server Listening"); printf("Server Listening\n"); printf("welcomeSocket output: %d\n", listenWelcomeSocket); } else { printf("Error!\n"); } // accept connection addr_size = sizeof(serverStorage); int newSocket = accept(welcomeSocket, (struct sockaddr *) &serverAddr, &addr_size); printf("Accepted new socket: %d\n", newSocket); // receive data int recvBytes = recv(newSocket, in_buffer, 1024, 0); printf("Received: '%s' from client\n", in_buffer); printf("Received: %d bytes from client\n", recvBytes); handleRequest(newSocket, in_buffer, "Server"); //int shutdownStatus = shutdown(newSocket, 0); int shutdownStatus = close(newSocket); printf("(server.c) Closed socket: %d, with status: %d\n", newSocket, shutdownStatus); usleep(50000); } while(true); int shutdownStatus = close(welcomeSocket); printf("(server.c) Closed socket: %d, with status: %d\n", welcomeSocket, shutdownStatus); return 0; }
bool LogerManager::configFromStringImpl(std::string content, bool isUpdate) { unsigned int sum = 0; for (std::string::iterator iter = content.begin(); iter != content.end(); ++iter) { sum += (unsigned char)*iter; } if (sum == _checksum) { return true; } _checksum = sum; std::map<std::string, LoggerInfo> loggerMap; if (!parseConfigFromString(content, loggerMap)) { printf(" !!! !!! !!! !!!\r\n"); printf(" !!! !!! log4z load config file error \r\n"); printf(" !!! !!! !!! !!!\r\n"); return false; } for (std::map<std::string, LoggerInfo>::iterator iter = loggerMap.begin(); iter != loggerMap.end(); ++iter) { LoggerId id = LOG4Z_INVALID_LOGGER_ID; id = findLogger(iter->second._key.c_str()); if (id == LOG4Z_INVALID_LOGGER_ID) { if (isUpdate) { continue; } else { id = createLogger(iter->second._key.c_str()); if (id == LOG4Z_INVALID_LOGGER_ID) { continue; } } } enableLogger(id, iter->second._enable); setLoggerName(id, iter->second._name.c_str()); setLoggerPath(id, iter->second._path.c_str()); setLoggerLevel(id, iter->second._level); setLoggerFileLine(id, iter->second._fileLine); setLoggerDisplay(id, iter->second._display); setLoggerOutFile(id, iter->second._outfile); setLoggerLimitsize(id, iter->second._limitsize); setLoggerMonthdir(id, iter->second._monthdir); } return true; }
bool ConverService::start() { createLogger("sybase conversion to oracle"); Logger::getInstance("sybase_oracle_conversion").fatal("Starting convering...\n"); m_ExportProcess = new ConverProcess(); if(!m_ExportProcess) { Service::printConsole("Distribution m_ExportProcess pointer failed.\n"); } if(!m_ExportProcess->run()) { return false; } Service::printConsole("Start database conversion Success.\n"); return true; }
bool LogerManager::configFromStringImpl(std::string content, bool isUpdate) { std::map<std::string, LoggerInfo> loggerMap; if (!parseConfigFromString(content, loggerMap)) { std::cout << " !!! !!! !!! !!!" << std::endl; std::cout << " !!! !!! log4z load config file error" << std::endl; std::cout << " !!! !!! !!! !!!" << std::endl; return false; } for (std::map<std::string, LoggerInfo>::iterator iter = loggerMap.begin(); iter != loggerMap.end(); ++iter) { LoggerId id = LOG4Z_INVALID_LOGGER_ID; id = findLogger(iter->second._key.c_str()); if (id == LOG4Z_INVALID_LOGGER_ID) { if (isUpdate) { continue; } else { id = createLogger(iter->second._key.c_str()); if (id == LOG4Z_INVALID_LOGGER_ID) { continue; } } } enableLogger(id, iter->second._enable); setLoggerName(id, iter->second._name.c_str()); setLoggerPath(id, iter->second._path.c_str()); setLoggerLevel(id, iter->second._level); setLoggerFileLine(id, iter->second._fileLine); setLoggerDisplay(id, iter->second._display); setLoggerOutFile(id, iter->second._outfile); setLoggerLimitsize(id, iter->second._limitsize); setLoggerMonthdir(id, iter->second._monthdir); } return true; }
int HarnessTestExecutor :: execute (InfoForExecutor &ir) { time_t rawtime; time ( &rawtime ); std::string nowStr(ctime (&rawtime)); nowStr = nowStr.substr(0,nowStr.size()-1); // remove newline if (strcasecmp (ir.logDestination.c_str (), LOGDESTINATION_CONSOLE) != 0) { cout << "[" << ir.test_sequence_number << "][" << nowStr << "]: " << "[start] " << ir.testID << std::endl; } copyToLocal (ir); if (validateParameters () == FAILURE) return FAILURE; createLogger (); //print_executor_environment (); if (prepareShellscript () == FAILURE) { LOG4CXX_INFO (_logger, "EXECUTOR returning FAILURE to the caller."); return FAILURE; } if (executeTestCase () == FAILURE) { LOG4CXX_INFO (_logger, "EXECUTOR returning FAILURE to the caller."); return FAILURE; } LOG4CXX_INFO (_logger, "EXECUTOR returning SUCCESS to the caller."); return SUCCESS; }
int main(int argc,char *argv[]) { const int BUF_SIZE=1024; const int CMDLEN=50; int sockfd;//atoi(argv[1]); struct FTS fts; char command[BUF_SIZE]; int index; struct COMMAND cmd; char user[CMDLEN]; char arg[BUF_SIZE]; const char* prompt="FTS> "; int numlogs,logfilesize; struct CONFIG_READER cfg; struct LOGGER lg; char ip[CMDLEN]; llg=≶ signal(SIGKILL,handle); createConfigReader(&cfg,"config.cfg"); //printf("after config reader\n"); getConfigValue("NLOGFILES",arg,&cfg); numlogs=atoi(arg); getConfigValue("LOGFILESIZE",arg,&cfg); logfilesize=atoi(arg); destroyConfigReader(&cfg); //printf("after destroy config reader\n"); createLogger(&lg,"client_log","./client_logs",numlogs,logfilesize); //printf("after create logger\n"); strncpy(arg,argv[1],BUF_SIZE); //printf("arg: %s\n",arg); strncpy(user,strtok(arg,"@"),BUF_SIZE); //printf("user: %s\n",user); strncpy(ip,strtok(NULL,"@"),BUF_SIZE); //printf("before connections\n"); fts.sockfd=sockfd=connectToServer(ip); fts.mode=FTS_MODE_ASCII; //printf("sock: %d\n",sockfd); //printf("user: %s\n",user); write(sockfd,user,strlen(user)); read(sockfd,&index,sizeof(index)); //printf("%d\n",index); if(index==-1) { puts("user not found"); exit(0); } puts("connected successfully"); while(1) { printf("%s",prompt); fflush(stdout); fgets(command,BUF_SIZE,stdin); while(command[0]=='\0' || command[0]==' ' || command[0]=='\n') fgets(command,BUF_SIZE,stdin); if(command[strlen(command)-1]=='\n') command[strlen(command)-1]='\0'; //printf("cmd: %s\n",command); writeToLogFile(command,&lg); fillCommandObject(command,&cmd); index=getCommandIndex(&cmd,(struct CMD_MAP *)&cmd_map); if(index < 0) { puts("Command not found"); continue; } cmd_map[index].handler(&cmd,&fts); destroyCommandObject (&cmd); } return (0); }
void MainThread::initLoggers() { // config file parameters Ice::PropertiesPtr props = context_.properties(); const std::string prefix = context_.tag() + ".Config."; const double timeWindowSec = orcaice::getPropertyAsDoubleWithDefault( props, prefix+"TimeWindowSec", 30.0 ); useFilenameTimestamps_ = (bool)orcaice::getPropertyAsIntWithDefault( props, prefix+"FilenameTimestamp", 1 ); string libNames = orcaice::getPropertyWithDefault( props, prefix+"FactoryLibNames", DEFAULT_FACTORY_LIB_NAME ); loadPluginLibraries( libNames ); // Get a list of required tags // // e.g. Tag.Requires.Laser0.Proxy, Tag.Requires.Laser1.Proxy, etc. // // note: interface tags can NOT be arbitrary. this will only work if a Odometry2d // interface uses a tag Odometry2dXX. // std::vector<std::string> requiredTags = orcaice::getRequiredTags( context_ ); stringstream ss; ss << "found " << requiredTags.size() << " required interfaces in the config file."; context_.tracer().info( ss.str() ); // Instantiate a logger for each required interface for ( unsigned int i=0; i<requiredTags.size(); ++i ) { context_.tracer().debug( "processing required interface tag="+requiredTags[i], 5); // parse interface tag into type and suffix std::string interfaceType; std::string interfaceTypeSuffix; orcalog::parseRequiredTag( requiredTags[i], interfaceType, interfaceTypeSuffix ); // look up format std::string format = orcaice::getPropertyWithDefault( props, prefix+requiredTags[i]+".Format", "asciigenerated" ); orcalog::LogWriterInfo logWriterInfo( context_ ); logWriterInfo.interfaceType = interfaceType; logWriterInfo.interfaceTag = interfaceType+interfaceTypeSuffix; std::string proxyString = orcaice::getRequiredInterfaceAsString( context_, logWriterInfo.interfaceTag ); logWriterInfo.comment = orcaice::resolveLocalPlatform( context_, proxyString ); logWriterInfo.format = format; logWriterInfo.filename = logWriterInfo.interfaceTag + ".log"; // // Create logger // this will throw on error, not catching it so it will kill us. // orcalog::SnapshotLogger *logger = createLogger( interfaceType ); try { logger->init( format, timeWindowSec ); } catch ( std::exception &e ) { // fatal error! context_.shutdown(); throw; } logWriterInfos_.push_back( logWriterInfo ); snapshotLoggers_.push_back( logger ); } // initialize and subscribe all interfaces for ( size_t i=0; i < snapshotLoggers_.size(); i++ ) snapshotLoggers_[i]->subscribe( logWriterInfos_[i].interfaceTag ); }
int main() { static const int SERVER_PORT = 7892; int clientSocket; int num_to_decrement; char in_buffer[1024], temp_in_buffer[1024], out_buffer[1024]; struct sockaddr_in serverAddr; socklen_t addr_size; char *message_format = "%s:%d"; char message[1024]; char* key = "decrement"; char* value = "50"; clientLogger = createLogger(__FILE__, LOG_LEVEL); //char* log_msg = malloc(sizeof(char) * 128); do { //memset(in_buffer, '\0', 1024); //memset(temp_in_buffer, '\0', 1024); // set up data to send num_to_decrement = atoi(value); sprintf(message, message_format, key, num_to_decrement); // set up socket clientSocket = socket(AF_INET, SOCK_STREAM, 0); createSockaddr_in(&serverAddr, SERVER_PORT, "127.0.0.1"); printf("%s\n", "before connecting to socket"); cLog("before connecting to socket"); // Connect to socket addr_size = sizeof(serverAddr); if(connect(clientSocket, (struct sockaddr *) &serverAddr, addr_size) < 0) { error("Error connecting\n"); } cLog("after connecting to socket"); printf("%s\n", "after connecting to socket"); strcpy(out_buffer, message); int sentBytes = send(clientSocket, out_buffer, sizeof(out_buffer), 0); printf("sent %d bytes from %s\n", sentBytes, "client"); //sprintf(log_msg, "sent %d bytes from %s\n", sentBytes, "client"); //cLog(log_msg); if (sentBytes == -1) { error(""); printf("error: %s\n", strerror(errno)); cLog("failed to send"); } else { cLog("succeeded in sending"); } printf("(client) just sent: %s\n", out_buffer); //sprintf(message_format, key, num_to_decrement); //sprintf(log_msg, message_format, key, num_to_decrement); //cLog(log_msg); //printf("\n"); // read from host recv(clientSocket, in_buffer, 1024, 0); if (!strcmp(in_buffer, "decrement:80")) { printf("special"); } strncpy(temp_in_buffer, in_buffer, 1024); cLog("received data from sever"); printf("Data received from server: '%s'\n", in_buffer); //sprintf(log_msg, "Data received from server: '%s'\n", in_buffer); //cLog(log_msg); printf("temp data: '%s'\n", temp_in_buffer); //sprintf(log_msg, "temp data: '%s'\n", temp_in_buffer); //cLog(log_msg); handleRequest(clientSocket, in_buffer, "client"); setKeyValue(&key, &value, temp_in_buffer); //printf("(client.c): key: %s, value: %s\n", key, value); int shutdownStatus = close(clientSocket); //sprintf(log_msg, "(client.c) Closed socket: %d, with status: %d\n", clientSocket, shutdownStatus); //cLog(log_msg); usleep(50000); } while(true); return 0; }