/** Update the Linux instance. */ void StaticDiskPartitionInstance::Update_Linux() { SCX_LOGTRACE(m_log, L"DiskPartition::Update_Linux():: Entering, DeviceID is:" + m_deviceID); bool opened = m_deps->open(StrToUTF8(m_deviceID).c_str(), O_RDONLY | O_NONBLOCK); if (!opened) { return; // Failure should already be logged by the open call } int ret; struct hd_geometry geo; memset(&geo,0,sizeof(geo)); ret = m_deps->ioctl(HDIO_GETGEO, &geo); if (ret || errno) { SCX_LOGERROR(m_log, L"Could not read disk geometry : ret=" + StrFrom(ret) + L" errno=" + StrFrom(errno)); return; //No use going on . . . } u_int64_t sectorSz=0; ret = m_deps->ioctl( BLKSSZGET, §orSz); if (ret || errno) { SCX_LOGERROR(m_log, L"ioctl BLKSSZGET failed : ret=" + StrFrom(ret) + L" errno=" + StrFrom(errno)); return; } u_int64_t blockDevBsz=0; ret = m_deps->ioctl( BLKBSZGET, &blockDevBsz); if (ret || errno) { SCX_LOGERROR(m_log, L"ioctl BLKBSZGET failed : ret=" + StrFrom(ret) + L" errno=" + StrFrom(errno)); return; } unsigned long partitionSize=0; ret = m_deps->ioctl( BLKGETSIZE, &partitionSize); if (ret || errno) { SCX_LOGERROR(m_log, L"ioctl BLKGETSIZE failed : ret=" + StrFrom(ret) + L" errno=" + StrFrom(errno)); return; } // fill in the fields in the instance of PartitionInformation m_partitionSize = partitionSize * sectorSz; m_blockSize = blockDevBsz; m_startingOffset = geo.start; m_numberOfBlocks = RoundToUnsignedInt( static_cast<double>(m_partitionSize) / static_cast<double>(m_blockSize)); }
//! Number of days in month //! \param[in] year Year of month //! \param[in] month Month of interest //! \returns Number of days in month of year //! \throws SCXInvalidArgumentException When month is ouside range unsigned DaysInMonth(scxyear year, scxmonth month) { switch (month) { case 1: return 31; case 2: return IsLeapYear(year)? 29: 28; case 3: return 31; case 4: return 30; case 5: return 31; case 6: return 30; case 7: return 31; case 8: return 31; case 9: return 30; case 10: return 31; case 11: return 30; case 12: return 31; default: throw SCXInvalidArgumentException(L"month", StrFrom(month), SCXSRCLOCATION); } }
/** Set user name */ void SCXUser::SetName() { struct passwd pwd; struct passwd *ppwd = NULL; long bufSize = sysconf(_SC_GETPW_R_SIZE_MAX); // Sanity check - all platforms have this, but never hurts to be certain if (bufSize < 1024) { bufSize = 1024; } std::vector<char> buf(bufSize); // Use reentrant form of getpwuid (it's reentrant, and it pacifies purify) #if !defined(sun) int rc = getpwuid_r(m_uid, &pwd, &buf[0], buf.size(), &ppwd); if (rc != 0) { ppwd = NULL; } #else ppwd = getpwuid_r(m_uid, &pwd, &buf[0], buf.size()); #endif if (ppwd) { m_name = StrFromUTF8(ppwd->pw_name); } else { m_name = StrFrom(m_uid); } }
/** Returns a formatted string with where an exception occured */ wstring SCXCodeLocation::Where() const { if (m_File.length()) { // Compose e.g. [my_file.cpp:434] return L"[" + m_File + L":" + StrFrom(m_Line) + L"]"; } else { return L"[unknown]"; } }
void WriteLogFileHeader( SCXHandle<std::wfstream> &stream, int logFileRunningNumber, SCXCalendarTime& procStartTimestamp ) { std::wstringstream continuationLogMsg; if ( logFileRunningNumber > 1 ) { continuationLogMsg << L"* Log file number: " << StrFrom(logFileRunningNumber) << std::endl; } (*stream) << L"*" << std::endl << L"* Microsoft System Center Cross Platform Mongo Extensions" << std::endl #if !defined(WIN32) << L"* Build number: " << CIMPROV_BUILDVERSION_MAJOR << L"." << CIMPROV_BUILDVERSION_MINOR << L"." << CIMPROV_BUILDVERSION_PATCH << L"-" << CIMPROV_BUILDVERSION_BUILDNR << L" " << CIMPROV_BUILDVERSION_STATUS << std::endl #endif << L"* Process id: " << StrFrom(SCXProcess::GetCurrentProcessID()) << std::endl << L"* Process started: " << procStartTimestamp.ToExtendedISO8601() << std::endl << continuationLogMsg.str() << L"*" << std::endl << L"* Log format: <date> <severity> [<code module>:<line number>:<process id>:<thread id>] <message>" << std::endl << L"*" << std::endl; }
/** Write the given list of application server instances to disk. \param[in] instances - vector of Application Server Instances to write to disk */ void PersistAppServerInstances::WriteToDisk( vector<SCXHandle<AppServerInstance> >& instances) { SCXHandle<SCXPersistDataWriter> pwriter= m_pmedia->CreateWriter(APP_SERVER_PROVIDER); pwriter->WriteStartGroup(APP_SERVER_METADATA); pwriter->WriteValue(APP_SERVER_NUMBER, StrFrom(instances.size())); pwriter->WriteEndGroup(); // Closing APP_METADATA int index = 0; for( vector<SCXHandle<AppServerInstance> >::iterator instance = instances.begin(); instance != instances.end(); ++instance, ++index) { pwriter->WriteStartGroup(APP_SERVER_INSTANCE); pwriter->WriteValue(APP_SERVER_DISK_PATH, (*instance)->GetDiskPath()); pwriter->WriteValue(APP_SERVER_ID, (*instance)->GetId()); pwriter->WriteValue(APP_SERVER_HTTP_PORT, (*instance)->GetHttpPort()); pwriter->WriteValue(APP_SERVER_HTTPS_PORT, (*instance)->GetHttpsPort()); pwriter->WriteValue(APP_SERVER_PROTOCOL, (*instance)->GetProtocol()); pwriter->WriteValue(APP_SERVER_IS_DEEP_MONITORED, StrFrom((*instance)->GetIsDeepMonitored())); pwriter->WriteValue(APP_SERVER_TYPE, (*instance)->GetType()); pwriter->WriteValue(APP_SERVER_VERSION, (*instance)->GetVersion()); pwriter->WriteValue(APP_SERVER_PROFILE, (*instance)->GetProfile()); pwriter->WriteValue(APP_SERVER_CELL, (*instance)->GetCell()); pwriter->WriteValue(APP_SERVER_NODE, (*instance)->GetNode()); pwriter->WriteValue(APP_SERVER_SERVER, (*instance)->GetServer()); pwriter->WriteEndGroup(); // Closing this instance } pwriter->DoneWriting(); }
/** Returns the line number where an exception occured, else returns "unknown" */ wstring SCXCodeLocation::WhichLine() const { // Return line number if present if (m_File.length()) { return StrFrom(m_Line); } else { return L"unknown"; } }
/** From the necessary file, read the domains and return a unique list of potential domains. */ vector<SCXFilePath> WebLogicFileReader::GetDomains() { SCX_LOGTRACE(m_log, L"WebLogicFileReader::GetDomains"); vector<SCXFilePath> domains; // Logic necessary for reading WebLogic 11g domains SCXFilePath domainRegistryXml; domainRegistryXml.SetDirectory(m_installationPath); domainRegistryXml.SetFilename( WEBLOGIC_DOMAIN_REGISTRY_XML_FILENAME); if (DoesDomainRegistryXmlExist(domainRegistryXml)) { ReadDomainRegistryXml(domainRegistryXml, domains); } // Logic necessary for reading WebLogic 10g domains SCXFilePath nodemanagerDomains; nodemanagerDomains.SetDirectory(m_installationPath); nodemanagerDomains.AppendDirectory(WEBLOGIC_NODEMANAGER_DOMAINS_DIRECTORY); nodemanagerDomains.SetFilename(WEBLOGIC_NODEMANAGER_DOMAINS_FILENAME); if (DoesNodemanagerDomainsExist(nodemanagerDomains)) { ReadNodemanagerDomains(nodemanagerDomains, domains); } // There may be duplicates in the list, it is necessary to // sort the list of domains and return only the unique instances. sort(domains.begin(), domains.end(), SortPath()); vector<SCXFilePath>::iterator tmp = unique(domains.begin(), domains.end()); domains.resize(tmp-domains.begin()); SCX_LOGTRACE(m_log, wstring(L"WebLogicFileReader::GetDomains() - "). append(L"Found ").append(StrFrom(domains.size())).append(L" domain(s)")); return domains; }
/** Constructor Parameters: procNumber - Number of processor, used as base for instance name isTotal - Whether the instance represents a Total value of a collection */ CPUInstance::CPUInstance(unsigned int procNumber, size_t sampleSize, bool isTotal) : EntityInstance(isTotal), m_UserCPU_tics(sampleSize), m_NiceCPU_tics(sampleSize), m_SystemCPUTime_tics(sampleSize), m_IdleCPU_tics(sampleSize), m_IOWaitTime_tics(sampleSize), m_IRQTime_tics(sampleSize), m_SoftIRQTime_tics(sampleSize), m_Total_tics(sampleSize) { m_log = SCXLogHandleFactory::GetLogHandle(L"scx.core.common.pal.system.cpu.cpuinstance"); if (isTotal) { m_procName = L"_Total"; } else { // The name of an instance is the processor number m_procName = StrFrom(procNumber); } SCX_LOGTRACE(m_log, wstring(L"CPUInstance default constructor - ").append(m_procName)); m_procNumber = procNumber; // Init data m_processorTime = 0; m_idleTime = 0; m_userTime = 0; m_niceTime = 0; m_privilegedTime = 0; m_iowaitTime = 0; m_interruptTime = 0; m_dpcTime = 0; m_queueLength = 0; }
bool StaticDiskPartitionInstance::GetBootDrivePath(wstring& bootpathStr) { SCX_LOGTRACE(m_log, L"DiskPartition::GetBootDrivePath():: Entering . . ."); bootpathStr.clear(); // buffer to store lines read from process output wstring curLine; wstring bootInterfacePath; // Determine Solaris boot disk using 'prtconf' and 'ls /dev/dsk' // cmdString stores the current process we are running via SCXProcess::Run() #if defined(sparc) #if PF_MAJOR == 5 && (PF_MINOR == 9 || PF_MINOR == 10) wstring cmdPrtString = L"/usr/sbin/prtconf -pv"; #elif PF_MAJOR == 5 && PF_MINOR == 11 wstring cmdPrtString = L"/sbin/prtconf -pv"; #else #error "Platform not supported" #endif #else// sparc wstring cmdPrtString = L"/usr/bin/grep bootpath /boot/solaris/bootenv.rc"; #endif std::string prtconfResult; std::string finalResult; std::istringstream processInputPrt; std::ostringstream processOutputPrt; std::ostringstream processErrPrt; try { int retCode = m_deps->Run(cmdPrtString, processInputPrt, processOutputPrt, processErrPrt, 15000); if (retCode) { SCX_LOGERROR(m_log, L"Error returned from prtconf, unable to determine boot partition. Error code=" + StrFrom(retCode)); return false; } prtconfResult = processOutputPrt.str(); SCX_LOGTRACE(m_log, L" Got this output from " + cmdPrtString + L" : " + StrFromUTF8(prtconfResult) ); size_t lengthCaptured = prtconfResult.length(); // Truncate trailing newline if there in captured output if (lengthCaptured > 0) { if (prtconfResult[lengthCaptured - 1] == '\n') { prtconfResult[lengthCaptured - 1] = '\0'; } } } catch(SCXCoreLib::SCXException &e) { SCX_LOGERROR(m_log, L"Unable to determine boot partition using prtconf ..." + e.What()); return false; } SCXRegexPtr solPrtconfPatternPtr(NULL); std::vector<wstring> matchingVector; // Let's build our RegEx: try { SCX_LOGTRACE(m_log, L" Using this regex on PrtConf output: " + c_SolPrtconfPattern ); solPrtconfPatternPtr = new SCXCoreLib::SCXRegex(c_SolPrtconfPattern); } catch(SCXCoreLib::SCXInvalidRegexException &e) { SCX_LOGERROR(m_log, L"Exception caught in compiling regex: " + e.What()); return false; } std::istringstream stringStrmPrtconf(prtconfResult); vector<wstring> allLines; // all lines read from prtconf output allLines.clear(); SCXStream::NLFs nlfs; SCXCoreLib::SCXStream::ReadAllLinesAsUTF8(stringStrmPrtconf, allLines, nlfs); for(vector<wstring>::iterator it = allLines.begin(); it != allLines.end(); it++) { curLine.assign(*it); matchingVector.clear(); // Let's get the Boot partition interface and drive letter from prtconf if (solPrtconfPatternPtr->ReturnMatch(curLine, matchingVector, 0)) { bootInterfacePath = matchingVector[1]; SCX_LOGTRACE(m_log, L"Found match of PrtConfPattern : " + bootInterfacePath); break; } } if (bootInterfacePath.size() == 0) { std::wstringstream warningMsg; if (matchingVector.size() > 0) { warningMsg << L"Couldn't find Boot Partition, regular expression error message was: " << matchingVector[0]; } else { warningMsg << L"Couldn't find Boot Partition."; } SCX_LOG(m_log, suppressor.GetSeverity(warningMsg.str()), warningMsg.str()); return false; } // Replace "disk" by "disk" or "sd" to normalize the boot interface path wstring from(L"disk"); size_t start_pos = bootInterfacePath.find(from); if(start_pos != std::string::npos) { bootInterfacePath.replace(start_pos, from.length(), L"(disk|sd)"); } wstring solLsPattern(c_SolLsPatternBeg); solLsPattern += bootInterfacePath; // Now we need to build up our pattern to find the bootdisk, using our results from above: SCXRegexPtr solLsPatternPtr(NULL); //Let's build our RegEx: try { SCX_LOGTRACE(m_log, L" Using this regex on ls -l /dev/dsk output: " + solLsPattern ); solLsPatternPtr = new SCXCoreLib::SCXRegex(solLsPattern); } catch(SCXCoreLib::SCXInvalidRegexException &e) { SCX_LOGERROR(m_log, L"Exception caught in compiling LS Pattern regex: " + e.What()); return false; } // Retrieve the bootdrive using the bootInterface and driveLetter wstring cmdStringLs = L"/usr/bin/ls -l /dev/dsk"; std::string devDskResult; std::istringstream processInputLs; std::ostringstream processOutputLs; std::ostringstream processErrLs; curLine.clear(); try { SCXCoreLib::SCXProcess::Run(cmdStringLs, processInputLs, processOutputLs, processErrLs, 15000); devDskResult = processOutputLs.str(); SCX_LOGTRACE(m_log, L" Got this output from " + cmdStringLs + L" : " + StrFromUTF8(devDskResult) ); size_t lengthCaptured = devDskResult.length(); // Truncate trailing newline if there in captured output if (lengthCaptured > 0) { if (devDskResult[lengthCaptured - 1] == '\n') { devDskResult[lengthCaptured - 1] = '\0'; } } } catch(SCXCoreLib::SCXException &e) { SCX_LOGERROR(m_log, L"Unable to determine boot partition..." + e.What()); return false; } std::istringstream stringStrmDevDsk(devDskResult); allLines.clear(); SCXCoreLib::SCXStream::ReadAllLinesAsUTF8(stringStrmDevDsk, allLines, nlfs); wstring bootDisk(L""); for(vector<wstring>::iterator it = allLines.begin(); it != allLines.end(); it++) { curLine.assign(*it); curLine.push_back('\n'); matchingVector.clear(); // Let's get the boot drive if (solLsPatternPtr->ReturnMatch(curLine, matchingVector, 0)) { bootDisk = matchingVector[1]; //e.g. "c1t0d0s0" break; } } //Check the results if (bootDisk.size() == 0) { std::wstringstream warningMsg; if (matchingVector.size() > 0) { warningMsg << L"Couldn't find Boot Drive, regular expression error message was: " << matchingVector[0]; } else { warningMsg << L"Couldn't find Boot Drive."; } SCX_LOG(m_log, suppressor.GetSeverity(warningMsg.str()), warningMsg.str()); return false; } bootpathStr = L"/dev/dsk/" + bootDisk; //e.g. "/dev/dsk/c1t0d0s0" return true; }