////////////////////////////////////////////////////////////////////////////////
// Set the trace facility to be used
////////////////////////////////////////////////////////////////////////////////
Uint32 Tracer::setTraceFacility(const String& traceFacility)
{
Uint32 retCode = 0;
Tracer* instance = _getInstance();
if (traceFacility.size() != 0)
{
Uint32 index = 0;
while (TRACE_FACILITY_LIST[index] != 0 )
{
if (String::equalNoCase( traceFacility,TRACE_FACILITY_LIST[index]))
{
if (index != instance->_traceFacility)
{
instance->_setTraceHandler(index);
}
retCode = 1;
break;
}
index++;
}
}
return retCode;
}
Logger& Logger::instance(
std::string,
size_t level, //! The logging threshold: every message with a level higher than this threshold will NOT be logged.
std::string filename, //! The logging file: If nothing or an empty string is passed, std::cout is the default target for all outputs.
bool dual
)
{
boost::mutex::scoped_lock lock(getInit_mutex());
if(!_getInstance())
{
if ( level > DEBUG3 ) level = DEBUG3;
_getInstance().reset(new Logger(level, filename, dual));
}
return *_getInstance();
}
////////////////////////////////////////////////////////////////////////////////
//Set the trace file
////////////////////////////////////////////////////////////////////////////////
Uint32 Tracer::setTraceFile(const char* traceFile)
{
if (*traceFile == 0)
{
return 1;
}
Tracer* instance = _getInstance();
String newTraceFile(traceFile);
if (instance->_runningOOP)
{
newTraceFile.append(".");
newTraceFile.append(instance->_oopTraceFileExtension);
}
if (_isValidTraceFile(newTraceFile))
{
instance->_traceFile = newTraceFile;
instance->_traceHandler->configurationUpdated();
}
else
{
return 1;
}
return 0;
}
int main (int argc, char** argv)
{
String stringVal;
verbose = (getenv("PEGASUS_TEST_VERBOSE")) ? true : false;
CIMClient client;
try
{
client.connectLocal ();
}
catch (Exception & e)
{
PEGASUS_STD (cerr) << e.getMessage () << PEGASUS_STD (endl);
return -1;
}
_enumerateInstanceNames(client);
_getInstance(client);
_setProperty(client, 7890);
_getProperty(client);
// getProperty() only returns CIMValues of type String.
value.get(stringVal);
PEGASUS_TEST_ASSERT(atoi((const char*)stringVal.getCString())==7890);
_setProperty(client,1234);
_getProperty(client);
// getProperty() only returns CIMValues of type String.
// Verify that setProperty worked as expected.
value.get(stringVal);
PEGASUS_TEST_ASSERT(atoi((const char*)stringVal.getCString())==1234);
return 0;
}
////////////////////////////////////////////////////////////////////////////////
// Notify the trare running out of process and provide the trace file extension
// for the out of process trace file.
////////////////////////////////////////////////////////////////////////////////
void Tracer::setOOPTraceFileExtension(const String& oopTraceFileExtension)
{
Tracer* instance = _getInstance();
instance->_oopTraceFileExtension = oopTraceFileExtension;
instance->_runningOOP=true;
instance->_traceMemoryBufferSize /= PEGASUS_TRC_BUFFER_OOP_SIZE_DEVISOR;
}
////////////////////////////////////////////////////////////////////////////////
//Called by all trace interfaces using a character string without format string
//to log message to trace file
////////////////////////////////////////////////////////////////////////////////
void Tracer::_traceCString(
const TraceComponentId traceComponent,
const char* message,
const char* cstring)
{
char* completeMessage;
Uint32 msgLen;
Uint32 usec,sec;
// Get the current system time and prepend to message
System::getCurrentTimeUsec(sec,usec);
//
// Allocate completeMessage.
// Needs to be updated if additional info is added
//
// Construct the message header
// The message header is in the following format
// timestamp: <component name> [file name:line number]
//
// Format string length calculation:
// 11(sec)+ 2('s-')+11(usec)+4('us: ')+1(' ')+1(\0) = 30
if (*message != '\0')
{
completeMessage = new char [strlen(message) +
strlen(TRACE_COMPONENT_LIST[traceComponent]) +
strlen(cstring) + 30];
msgLen = sprintf(completeMessage, "%us-%uus: %s %s%s", sec, usec,
TRACE_COMPONENT_LIST[traceComponent], message, cstring);
}
else
{
//
// Allocate messageHeader.
// Needs to be updated if additional info is added
//
// Format string length calculation:
// 11(sec)+2('s-')+11(usec)+4('us: ')+
// +2(' [')+1(':')+3(']: ')+1(\0) = 35
completeMessage = new char[2 * _STRLEN_MAX_PID_TID +
strlen(TRACE_COMPONENT_LIST[traceComponent]) +
strlen(cstring) +35];
msgLen = sprintf(completeMessage, "%us-%uus: %s [%u:%s] %s", sec, usec,
TRACE_COMPONENT_LIST[traceComponent],
System::getPID(), Threads::id().buffer,
cstring);
}
// Call trace file handler to write message
_getInstance()->_traceHandler->handleMessage(completeMessage,msgLen);
delete [] completeMessage;
}
////////////////////////////////////////////////////////////////////////////////
//Validate the trace file
////////////////////////////////////////////////////////////////////////////////
Boolean Tracer::isValidFileName(const char* filePath)
{
Tracer* instance = _getInstance();
String testTraceFile(filePath);
if (instance->_runningOOP)
{
testTraceFile.append(".");
testTraceFile.append(instance->_oopTraceFileExtension);
}
return _isValidTraceFile(testTraceFile);
}
//set the trace file number for rolling only when the tracing is on a file
void Tracer::setMaxTraceFileNumber(const String &maxTraceFileNumber)
{
Tracer *inst = _getInstance();
if ( inst->getTraceFacility() == TRACE_FACILITY_FILE )
{
Uint32 numberOfTraceFiles = 0;
tracePropertyToUint32(maxTraceFileNumber, numberOfTraceFiles);
//Safe to typecast here as we know that handler is of type file
TraceFileHandler *hdlr = (TraceFileHandler*) (inst->_traceHandler);
hdlr->setMaxTraceFileNumber(numberOfTraceFiles);
}
}
//set the trace file size only when the tracing is on a file
void Tracer::setMaxTraceFileSize(const String &size)
{
Tracer *inst = _getInstance();
if ( inst->getTraceFacility() == TRACE_FACILITY_FILE )
{
Uint32 traceFileSizeKBytes = 0;
tracePropertyToUint32(size, traceFileSizeKBytes);
//Safe to typecast here as we know that handler is of type file
TraceFileHandler *hdlr = (TraceFileHandler*) (inst->_traceHandler);
hdlr->setMaxTraceFileSize(traceFileSizeKBytes*1024);
}
}
/**{{{ proto Mylogs::logInit
*/
PHP_METHOD(Mylogs, logInit) {
long level, maxNum, maxSize;
char *logPath, *fileName;
int logPath_len, fileName_len;
zval *instance = _getInstance();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lllss", &level, &maxNum, &maxSize, &logPath, &logPath_len, &fileName, &fileName_len) == FAILURE)
return;
zend_update_property_long(mylogs_ce, instance, ZEND_STRL(MYLOGS_LEVEL), level TSRMLS_CC);
zend_update_property_long(mylogs_ce, instance, ZEND_STRL(MYLOGS_MAXFILE_NUM), maxNum TSRMLS_CC);
zend_update_property_long(mylogs_ce, instance, ZEND_STRL(MYLOGS_MAXFILE_SIZE), maxSize TSRMLS_CC);
zend_update_property_string(mylogs_ce, instance, ZEND_STRL(MYLOGS_PATH), logPath TSRMLS_CC);
zend_update_property_string(mylogs_ce, instance, ZEND_STRL(MYLOGS_FILE_NAME), fileName TSRMLS_CC);
RETURN_TRUE;
}
////////////////////////////////////////////////////////////////////////////////
// Set the size of the memory trace buffer
////////////////////////////////////////////////////////////////////////////////
Boolean Tracer::setTraceMemoryBufferSize(Uint32 bufferSize)
{
Tracer* instance = _getInstance();
if (instance->_runningOOP)
{
// in OOP we reduce the trace memory buffer by factor
// PEGASUS_TRC_BUFFER_OOP_SIZE_DEVISOR
instance->_traceMemoryBufferSize =
bufferSize / PEGASUS_TRC_BUFFER_OOP_SIZE_DEVISOR;
}
else
{
instance->_traceMemoryBufferSize = bufferSize;
}
// If we decide to dynamically change the trace buffer size,
// this is where it needs to be implemented.
return true;
}
/* assume lock is held */
Category& HierarchyMaintainer::_getInstance(const std::string& name) {
Category* result;
result = _getExistingInstance(name);
if (NULL == result) {
if (name == "") {
result = make_category(name, NULL, Priority::INFO);
} else {
std::string parentName;
size_t dotIndex = name.find_last_of('.');
if (name.length() <= dotIndex) {
parentName = "";
} else {
parentName = name.substr(0, dotIndex);
}
Category& parent = _getInstance(parentName);
result = make_category(name, &parent, Priority::NOTSET);
}
_categoryMap[name] = result;
}
return *result;
}
////////////////////////////////////////////////////////////////////////////////
//Traces the given string - Overloaded to include the fileName and line number
//of trace origin.
////////////////////////////////////////////////////////////////////////////////
void Tracer::traceCString(
const char* fileName,
const Uint32 lineNum,
const TraceComponentId traceComponent,
const char* cstring)
{
char* message;
Uint32 msgLen;
Uint32 usec,sec;
// Get the current system time
System::getCurrentTimeUsec(sec,usec);
//
// Allocate memory for the message string
// Needs to be updated if additional info is added
//
message = new char [strlen(fileName) +
_STRLEN_MAX_UNSIGNED_INT + (_STRLEN_MAX_PID_TID * 2) + 8 +
strlen(TRACE_COMPONENT_LIST[traceComponent]) +
strlen(cstring) + 30];
msgLen = sprintf(message, "%us-%uus: %s [%u:%s:%s:%u]: %s",
sec,
usec,
TRACE_COMPONENT_LIST[traceComponent],
System::getPID(),
Threads::id().buffer,
fileName,
lineNum,
cstring);
// Call trace file handler to write message
_getInstance()->_traceHandler->handleMessage(message,msgLen);
delete [] message;
}
/** {{{ Mylogs::err
*/
PHP_METHOD(Mylogs, err) {
char *msg;
int msg_len;
zval *instance, *level, **_level;
zend_class_entry *ce;
if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &msg, &msg_len) == FAILURE)
return;
instance = _getInstance();
ce = Z_OBJCE_P(instance);
level = zend_read_property(mylogs_ce, instance, ZEND_STRL(MYLOGS_LEVEL), 0 TSRMLS_CC);
zend_hash_find(&ce->constants_table, ZEND_STRS(LOG_ERR), (void **)&_level);
if(Z_LVAL_P(level) > Z_LVAL_PP(_level)) {
RETURN_TRUE;
}
if(_log(msg) == SUCCESS) {
RETURN_TRUE;
}
RETURN_FALSE;
}
Category& HierarchyMaintainer::getInstance(const std::string& name) {
threading::ScopedLock lock(_categoryMutex);
return _getInstance(name);
}
/**{{{ proto Mylogs::getInstance
* singleton pattern, to get the instance
*/
PHP_METHOD(Mylogs, getInstance) {
zval *instance = _getInstance();
RETURN_ZVAL(instance, 1, 0);
}
/**{{{
*/
int _log(char *str) {
zval *logPath, *fileName, *maxSize, *maxNum, *instance;
char *fileHandler = NULL, *fileHandlerTmp = NULL, *fileHandlerTmpNew = NULL, *format_time = NULL, *format_str = NULL;
struct stat buf;
FILE *fp = NULL;
instance = _getInstance();
maxNum = zend_read_property(mylogs_ce, instance, ZEND_STRL(MYLOGS_MAXFILE_NUM), 0 TSRMLS_CC);
maxSize = zend_read_property(mylogs_ce, instance, ZEND_STRL(MYLOGS_MAXFILE_SIZE), 0 TSRMLS_CC);
logPath = zend_read_property(mylogs_ce, instance, ZEND_STRL(MYLOGS_PATH), 0 TSRMLS_CC);
fileName = zend_read_property(mylogs_ce, instance, ZEND_STRL(MYLOGS_FILE_NAME), 0 TSRMLS_CC);
format_time = _formatTime();
spprintf(&fileHandler, 0, "%s%s.log", Z_STRVAL_P(logPath), Z_STRVAL_P(fileName));
spprintf(&format_str, 0, "%s %s\n", format_time, str);
_efree_char(format_time);
if(VCWD_ACCESS(fileHandler, 0) == F_OK)
{
stat(fileHandler, &buf);
if(buf.st_size >= Z_LVAL_P(maxSize))
{
int index = 1;
for(; index < Z_LVAL_P(maxNum); index++)
{
spprintf(&fileHandlerTmp, 0, "%s%s_%d.log", Z_STRVAL_P(logPath), Z_STRVAL_P(fileName), index);
if(VCWD_ACCESS(fileHandlerTmp, 0) != F_OK) {
break;
} else {
_efree_char(fileHandlerTmp);
}
}
if(index == Z_LVAL_P(maxNum))
index--;
for(; index >= 1; index--)
{
spprintf(&fileHandlerTmpNew, 0, "%s%s_%d.log", Z_STRVAL_P(logPath), Z_STRVAL_P(fileName), index);
spprintf(&fileHandlerTmp, 0, "%s%s_%d.log", Z_STRVAL_P(logPath), Z_STRVAL_P(fileName), (index - 1));
VCWD_RENAME(fileHandlerTmp, fileHandlerTmpNew);
_efree_char(fileHandlerTmp);
_efree_char(fileHandlerTmpNew);
}
spprintf(&fileHandlerTmpNew, 0, "%s%s_1.log", Z_STRVAL_P(logPath), Z_STRVAL_P(fileName));
VCWD_RENAME(fileHandler, fileHandlerTmpNew);
_efree_char(fileHandlerTmpNew);
}
}
if(fileHandler != NULL) {
fp = VCWD_FOPEN(fileHandler, "a+b");
efree(fileHandler);
}
if(fp == NULL)
{
_efree_char(format_str);
return FAILURE;
}
fputs(format_str, fp);
_efree_char(format_str);
fclose(fp);
return SUCCESS;
}
////////////////////////////////////////////////////////////////////////////////
// Flushes the trace buffer to traceFilePath. This method will only
// have an effect when traceFacility=Memory.
////////////////////////////////////////////////////////////////////////////////
void Tracer::flushTrace()
{
_getInstance()->_traceHandler->flushTrace();
return;
}
////////////////////////////////////////////////////////////////////////////////
// Get the trace facility in use
////////////////////////////////////////////////////////////////////////////////
Uint32 Tracer::getTraceFacility()
{
return _getInstance()->_traceFacility;
}
int main(const int argc, const char **argv)
{
// error if no args
if (argv[1] == 0)
{
_usage();
return 1;
}
SSLContext *sslContext = 0; // initialized for unencrypted connection
_c.setTimeout(TIMEOUT);
// Get hostname from environment, if defined
char *p = getenv("CIM_HOST");
if (p) _hostName = p;
// Get port number, if defined
char *pn = getenv("CIM_PORT");
if (pn) _portNumber = atol(pn);
if (p)
{
// hostname was specified, we will not connect local
// so decide whether encrypted or not
char *s = getenv("CIM_NOSSL");
if (s) // don't use ssl (not encrypted)
{
if (!pn) _portNumber = 5988; // use 5988 if no port specified
}
else
{
try
{
sslContext = new SSLContext(PEGASUS_SSLCLIENT_CERTIFICATEFILE,
verifyServerCertificate,
PEGASUS_SSLCLIENT_RANDOMFILE
/* "/var/opt/wbem/ssl.rnd" */);
}
catch (Exception &e)
{
cerr << e.getMessage() << endl;
return 1;
}
if (!pn) _portNumber = 5989; // use 5989 if no port specified
}
}
// Get namespace from environment or use default
p = getenv("CIM_NAMESPACE");
_nameSpace = (p==0)? DEFAULT_NAMESPACE:p;
// Get user from environment or don't specify
p = getenv("CIM_USER");
_userName = (p==0)? String::EMPTY : p;
// Get password from environment or use empty
p = getenv("CIM_PASSWORD");
_passWord = (p==0)? String::EMPTY : p;
try
{
if (String::equal(_hostName,String::EMPTY)) _c.connectLocal();
else
// hostname was specified; do remote connect
{
if (sslContext) _c.connect(_hostName, _portNumber, *sslContext, _userName, _passWord);
else _c.connect(_hostName, _portNumber, _userName, _passWord);
}
}
catch(Exception& e)
{
cerr << e.getMessage() << endl;
return 1;
}
// command is first arg
const char *cmd = argv[1];
if (String::equalNoCase(cmd,"getClass") ||
String::equalNoCase(cmd,"gc"))
return _getClass(argc-2,&argv[2]);
else if (String::equalNoCase(cmd,"enumerateClasses") ||
String::equalNoCase(cmd,"ec"))
return _enumerateClasses(argc-2,&argv[2]);
else if (String::equalNoCase(cmd,"enumerateClassNames") ||
String::equalNoCase(cmd,"ecn"))
return _enumerateClassNames(argc-2,&argv[2]);
else if (String::equalNoCase(cmd,"getInstance") ||
String::equalNoCase(cmd,"gi"))
return _getInstance(argc-2,&argv[2]);
else if (String::equalNoCase(cmd,"enumerateInstances") ||
String::equalNoCase(cmd,"ei"))
return _enumerateInstances(argc-2,&argv[2]);
else if (String::equalNoCase(cmd,"enumerateInstanceNames") ||
String::equalNoCase(cmd,"ein"))
return _enumerateInstanceNames(argc-2,&argv[2]);
else if (String::equalNoCase(cmd,"getProperty") ||
String::equalNoCase(cmd,"gp"))
return _getProperty(argc-2,&argv[2]);
else if (String::equalNoCase(cmd,"setProperty") ||
String::equalNoCase(cmd,"sp"))
return _setProperty(argc-2,&argv[2]);
else if (String::equalNoCase(cmd,"invokeMethod") ||
String::equalNoCase(cmd,"im"))
return _invokeMethod(argc-2,&argv[2]);
else if (String::equalNoCase(cmd,"createClass") ||
String::equalNoCase(cmd,"cc"))
return _createClass(argc-2,&argv[2]);
else if (String::equalNoCase(cmd,"modifyClass") ||
String::equalNoCase(cmd,"mc"))
return _modifyClass(argc-2,&argv[2]);
else if (String::equalNoCase(cmd,"deleteClass") ||
String::equalNoCase(cmd,"dc"))
return _deleteClass(argc-2,&argv[2]);
else if (String::equalNoCase(cmd,"createInstance") ||
String::equalNoCase(cmd,"ci"))
return _createInstance(argc-2,&argv[2]);
else if (String::equalNoCase(cmd,"modifyInstance") ||
String::equalNoCase(cmd,"mi"))
return _modifyInstance(argc-2,&argv[2]);
else if (String::equalNoCase(cmd,"deleteInstance") ||
String::equalNoCase(cmd,"di"))
return _deleteInstance(argc-2,&argv[2]);
else if (String::equalNoCase(cmd,"associators") ||
String::equalNoCase(cmd,"a"))
return _associators(argc-2,&argv[2]);
else if (String::equalNoCase(cmd,"associatorNames") ||
String::equalNoCase(cmd,"an"))
return _associatorNames(argc-2,&argv[2]);
else if (String::equalNoCase(cmd,"references") ||
String::equalNoCase(cmd,"r"))
return _references(argc-2,&argv[2]);
else if (String::equalNoCase(cmd,"referenceNames") ||
String::equalNoCase(cmd,"rn"))
return _referenceNames(argc-2,&argv[2]);
else if (String::equalNoCase(cmd,"execQuery") ||
String::equalNoCase(cmd,"exq"))
return _execQuery(argc-2,&argv[2]);
else if (String::equalNoCase(cmd,"getQualifier") ||
String::equalNoCase(cmd,"gq"))
return _getQualifier(argc-2,&argv[2]);
else if (String::equalNoCase(cmd,"setQualifier") ||
String::equalNoCase(cmd,"sq"))
return _setQualifier(argc-2,&argv[2]);
else if (String::equalNoCase(cmd,"deleteQualifier") ||
String::equalNoCase(cmd,"dq"))
return _deleteQualifier(argc-2,&argv[2]);
else if (String::equalNoCase(cmd,"enumerateQualifiers") ||
String::equalNoCase(cmd,"eq"))
return _enumerateQualifiers(argc-2,&argv[2]);
else
{
cerr << cmd << ": Invalid CIM operation."<< endl;
_usage();
return 1;
}
}
