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;
}
