/**
Get the value for the spcified resource from a specified instance
\param[in] resource Name of resource to get
\param[in] processinst Instance to get resource from
\returns Value for specifed resource
\throws SCXInternalErrorException If given resource not handled
*/
scxulong ProcessProvider::GetResource(const std::wstring &resource, SCXCoreLib::SCXHandle<SCXSystemLib::ProcessInstance> processinst)
{
scxulong res = 0;
bool gotResource = false;
if (StrCompare(resource, L"CPUTime", true) == 0)
{
unsigned int cputime;
gotResource = processinst->GetCPUTime(cputime);
res = static_cast<scxulong>(cputime);
}
else if (StrCompare(resource, L"BlockReadsPerSecond", true) == 0)
{
gotResource = processinst->GetBlockReadsPerSecond(res);
}
else if (StrCompare(resource, L"BlockWritesPerSecond", true) == 0)
{
gotResource = processinst->GetBlockWritesPerSecond(res);
}
else if (StrCompare(resource, L"BlockTransfersPerSecond", true) == 0)
{
gotResource = processinst->GetBlockTransfersPerSecond(res);
}
else if (StrCompare(resource, L"PercentUserTime", true) == 0)
{
gotResource = processinst->GetPercentUserTime(res);
}
else if (StrCompare(resource, L"PercentPrivilegedTime", true) == 0)
{
gotResource = processinst->GetPercentPrivilegedTime(res);
}
else if (StrCompare(resource, L"UsedMemory", true) == 0)
{
gotResource = processinst->GetUsedMemory(res);
}
else if (StrCompare(resource, L"PercentUsedMemory", true) == 0)
{
gotResource = processinst->GetPercentUsedMemory(res);
}
else if (StrCompare(resource, L"PagesReadPerSec", true) == 0)
{
gotResource = processinst->GetPagesReadPerSec(res);
}
else
{
throw UnknownResourceException(resource, SCXSRCLOCATION);
}
if ( ! gotResource)
{
throw SCXInternalErrorException(StrAppend(L"GetResource: Failed to get resouce: ", resource), SCXSRCLOCATION);
}
return res;
}
MI_BEGIN_NAMESPACE
static void EnumerateOneInstance(
Context& context,
SCX_MemoryStatisticalInformation_Class& inst,
bool keysOnly,
SCXCoreLib::SCXHandle<SCXSystemLib::MemoryInstance> meminst)
{
// Populate the key values
inst.Name_value("Memory");
if (!keysOnly)
{
scxulong physmem = 0;
scxulong resmem = 0;
scxulong usermem = 0;
scxulong avail = 0;
scxulong data = 0;
scxulong data2 = 0;
inst.Caption_value("Memory information");
inst.Description_value("Memory usage and performance statistics");
inst.IsAggregate_value(meminst->IsTotal());
if (meminst->GetTotalPhysicalMemory(physmem))
{
// Adjust numbers from PAL to Megabytes
physmem = BytesToMegaBytes(physmem);
if (meminst->GetReservedMemory(resmem))
{
resmem = BytesToMegaBytes(resmem);
}
else
{
resmem = 0;
}
// If available, get memory unavailable for user processes and remove it from physical memory
usermem = physmem - resmem;
}
if (meminst->GetAvailableMemory(avail))
{
// Adjust numbers from PAL to Megabytes
avail = BytesToMegaBytes(avail);
inst.AvailableMemory_value(avail);
// If we have a number for physical memory use it to compute a percentage
if (usermem > 0)
{
// Need an unsigned char since this is what is required by the MOF
unsigned char percent = static_cast<unsigned char> (GetPercentage(0, avail, 0, usermem));
inst.PercentAvailableMemory_value(percent);
}
}
if (meminst->GetUsedMemory(data))
{
// Adjust numbers from PAL to Megabytes
data = BytesToMegaBytes(data);
inst.UsedMemory_value(data);
// If we have a number for physical memory use it to compute a percentage
if (usermem > 0)
{
unsigned char percent = static_cast<unsigned char> (GetPercentage(0, data, 0, usermem));
inst.PercentUsedMemory_value(percent);
}
}
{
data = 0;
unsigned char percent = static_cast<unsigned char> (0);
if (meminst->GetCacheSize(data) && usermem > 0)
{
percent = static_cast<unsigned char> (GetPercentage(0, BytesToMegaBytes(data), 0, usermem));
}
inst.PercentUsedByCache_value(percent);
}
bool pageReadsAvailable = meminst->GetPageReads(data);
bool pageWritesAvailable = meminst->GetPageWrites(data2);
if (pageReadsAvailable && pageWritesAvailable)
{
inst.PagesPerSec_value(data + data2);
}
if (pageReadsAvailable)
{
inst.PagesReadPerSec_value(data);
}
if (pageWritesAvailable)
{
inst.PagesWrittenPerSec_value(data2);
}
if (meminst->GetAvailableSwap(data))
{
// Adjust numbers from PAL to Megabytes
data = BytesToMegaBytes(data);
inst.AvailableSwap_value(data);
if (meminst->GetTotalSwap(data2))
{
// Adjust numbers from PAL to Megabytes
data2 = BytesToMegaBytes(data2);
unsigned char percent = static_cast<unsigned char> (GetPercentage(0, data, 0, data2));
inst.PercentAvailableSwap_value(percent);
}
}
if (meminst->GetUsedSwap(data))
{
// Adjust numbers from PAL to Megabytes
data = BytesToMegaBytes(data);
inst.UsedSwap_value(data);
if (meminst->GetTotalSwap(data2))
{
// Adjust numbers from PAL to Megabytes
data2 = BytesToMegaBytes(data2);
unsigned char percent = static_cast<unsigned char> (GetPercentage(0, data, 0, data2));
inst.PercentUsedSwap_value(percent);
}
}
}
context.Post(inst);
}
/**
Set all properties from the ProcessInstance in the SCXInstance
\param[in] processinst - Process instance to get data from
\param[in] inst - Instance to populate
\param[in] cimtype - Type of CIM Class to return
\throws SCXInvalidArgumentException - If the instance can not be converted to a ProcessInstance
This method knows how to map the values of the Process PAL to the CMPI class
definition.
*/
void ProcessProvider::AddProperties(SCXCoreLib::SCXHandle<SCXSystemLib::ProcessInstance> processinst, SCXInstance &inst, SupportedCimClasses cimtype) // private
{
if (processinst == NULL)
{
throw SCXInvalidArgumentException(L"einst", L"Not a ProcessInstance", SCXSRCLOCATION);
}
SCX_LOGTRACE(m_log, L"ProcessProvider AddPropeties()");
if (eSCX_UnixProcessStatisticalInformation == cimtype)
{
unsigned int uint = 0;
scxulong ulong = 0;
if (processinst->GetRealData(ulong))
{
SCXProperty prop(L"RealData", ulong);
inst.AddProperty(prop);
}
if (processinst->GetRealStack(ulong))
{
SCXProperty prop(L"RealStack", ulong);
inst.AddProperty(prop);
}
if (processinst->GetVirtualText(ulong))
{
SCXProperty prop(L"VirtualText", ulong);
inst.AddProperty(prop);
}
if (processinst->GetVirtualData(ulong))
{
SCXProperty prop(L"VirtualData", ulong);
inst.AddProperty(prop);
}
if (processinst->GetVirtualStack(ulong))
{
SCXProperty prop(L"VirtualStack", ulong);
inst.AddProperty(prop);
}
if (processinst->GetVirtualMemoryMappedFileSize(ulong))
{
SCXProperty prop(L"VirtualMemoryMappedFileSize", ulong);
inst.AddProperty(prop);
}
if (processinst->GetVirtualSharedMemory(ulong))
{
SCXProperty prop(L"VirtualSharedMemory", ulong);
inst.AddProperty(prop);
}
if (processinst->GetCpuTimeDeadChildren(ulong))
{
SCXProperty prop(L"CpuTimeDeadChildren", ulong);
inst.AddProperty(prop);
}
if (processinst->GetSystemTimeDeadChildren(ulong))
{
SCXProperty prop(L"SystemTimeDeadChildren", ulong);
inst.AddProperty(prop);
}
if (processinst->GetRealText(ulong))
{
SCXProperty prop(L"RealText", ulong);
inst.AddProperty(prop);
}
if (processinst->GetCPUTime(uint))
{
SCXProperty prop(L"CPUTime", uint);
inst.AddProperty(prop);
}
if (processinst->GetBlockWritesPerSecond(ulong))
{
SCXProperty prop(L"BlockWritesPerSecond", ulong);
inst.AddProperty(prop);
}
if (processinst->GetBlockReadsPerSecond(ulong))
{
SCXProperty prop(L"BlockReadsPerSecond", ulong);
inst.AddProperty(prop);
}
if (processinst->GetBlockTransfersPerSecond(ulong))
{
SCXProperty prop(L"BlockTransfersPerSecond", ulong);
inst.AddProperty(prop);
}
if (processinst->GetPercentUserTime(ulong))
{
SCXProperty prop(L"PercentUserTime", (unsigned char) ulong);
inst.AddProperty(prop);
}
if (processinst->GetPercentPrivilegedTime(ulong))
{
SCXProperty prop(L"PercentPrivilegedTime", (unsigned char) ulong);
inst.AddProperty(prop);
}
if (processinst->GetUsedMemory(ulong))
{
SCXProperty prop(L"UsedMemory", ulong);
inst.AddProperty(prop);
}
if (processinst->GetPercentUsedMemory(ulong))
{
SCXProperty prop(L"PercentUsedMemory", (unsigned char) ulong);
inst.AddProperty(prop);
}
if (processinst->GetPagesReadPerSec(ulong))
{
SCXProperty prop(L"PagesReadPerSec", ulong);
inst.AddProperty(prop);
}
}
else if (eSCX_UnixProcess == cimtype)
{
std::string name("");
std::vector<std::string> params;
std::wstring str(L"");
unsigned int uint = 0;
unsigned short ushort = 0;
scxulong ulong = 0;
SCXCoreLib::SCXCalendarTime ctime;
int pid = 0;
if (processinst->GetOtherExecutionDescription(str))
{
SCXProperty prop(L"OtherExecutionDescription", str);
inst.AddProperty(prop);
}
if (processinst->GetKernelModeTime(ulong))
{
SCXProperty prop(L"KernelModeTime", ulong);
inst.AddProperty(prop);
}
if (processinst->GetUserModeTime(ulong))
{
SCXProperty prop(L"UserModeTime", ulong);
inst.AddProperty(prop);
}
if (processinst->GetWorkingSetSize(ulong))
{
SCXProperty prop(L"WorkingSetSize", ulong);
inst.AddProperty(prop);
}
if (processinst->GetProcessSessionID(ulong))
{
SCXProperty prop(L"ProcessSessionID", ulong);
inst.AddProperty(prop);
}
if (processinst->GetProcessTTY(name))
{
SCXProperty prop(L"ProcessTTY", StrFromMultibyte(name));
inst.AddProperty(prop);
}
if (processinst->GetModulePath(name))
{
SCXProperty prop(L"ModulePath", StrFromMultibyte(name));
inst.AddProperty(prop);
}
if (processinst->GetParameters(params))
{
std::vector<SCXProperty> props;
for (std::vector<std::string>::const_iterator iter = params.begin();
iter != params.end(); ++iter)
{
SCXProperty item(L"", StrFromMultibyte(*iter));
props.push_back(item);
}
SCXProperty prop(L"Parameters", props);
inst.AddProperty(prop);
}
if (processinst->GetProcessWaitingForEvent(name))
{
SCXProperty prop(L"ProcessWaitingForEvent", StrFromMultibyte(name));
inst.AddProperty(prop);
}
if (processinst->GetName(name))
{
SCXProperty name_prop(L"Name", StrFromMultibyte(name));
inst.AddProperty(name_prop);
}
if (processinst->GetPriority(uint))
{
SCXProperty prio_prop(L"Priority", uint);
inst.AddProperty(prio_prop);
}
if (processinst->GetExecutionState(ushort))
{
SCXProperty state_prop(L"ExecutionState", ushort);
inst.AddProperty(state_prop);
}
if (processinst->GetCreationDate(ctime))
{
SCXProperty cdate_prop(L"CreationDate", ctime);
inst.AddProperty(cdate_prop);
}
if (processinst->GetTerminationDate(ctime))
{
SCXProperty edate_prop(L"TerminationDate", ctime);
inst.AddProperty(edate_prop);
}
if (processinst->GetParentProcessID(pid))
{
SCXProperty ppid_prop(L"ParentProcessID", StrFrom(pid));
inst.AddProperty(ppid_prop);
}
if (processinst->GetRealUserID(ulong))
{
SCXProperty user_prop(L"RealUserID", ulong);
inst.AddProperty(user_prop);
}
if (processinst->GetProcessGroupID(ulong))
{
SCXProperty group_prop(L"ProcessGroupID", ulong);
inst.AddProperty(group_prop);
}
if (processinst->GetProcessNiceValue(uint))
{
SCXProperty nice_prop(L"ProcessNiceValue", uint);
inst.AddProperty(nice_prop);
}
}
}
MI_BEGIN_NAMESPACE
static void EnumerateOneInstance(Context& context,
SCX_UnixProcessStatisticalInformation_Class& inst, bool keysOnly,
SCXCoreLib::SCXHandle<SCXSystemLib::ProcessInstance> processinst)
{
SCXLogHandle& log = SCXCore::g_ProcessProvider.GetLogHandle();
// Add the key properties first.
scxulong pid;
if (processinst->GetPID(pid))
{
inst.Handle_value(StrToUTF8(StrFrom(pid)).c_str());
}
// Add keys of scoping operating system
try {
SCXCoreLib::NameResolver mi;
inst.CSName_value(StrToMultibyte(mi.GetHostDomainname()).c_str());
} catch (SCXException& e){
SCX_LOGWARNING(log, StrAppend(
StrAppend(L"Can't read host/domainname because ", e.What()),
e.Where()));
}
try {
SCXSystemLib::SCXOSTypeInfo osinfo;
inst.OSName_value(StrToMultibyte(osinfo.GetOSName(true)).c_str());
} catch (SCXException& e){
SCX_LOGWARNING(log, StrAppend(
StrAppend(L"Can't read OS name because ", e.What()),
e.Where()));
}
inst.CSCreationClassName_value("SCX_ComputerSystem");
inst.OSCreationClassName_value("SCX_OperatingSystem");
inst.ProcessCreationClassName_value("SCX_UnixProcessStatisticalInformation");
std::string name;
if (processinst->GetName(name))
{
inst.Name_value(name.c_str());
}
if (!keysOnly)
{
unsigned int uint = 0;
scxulong ulong = 0;
inst.Description_value("A snapshot of a current process");
inst.Caption_value("Unix process information");
if (processinst->GetRealData(ulong))
{
inst.RealData_value(ulong);
}
if (processinst->GetRealStack(ulong))
{
inst.RealStack_value(ulong);
}
if (processinst->GetVirtualText(ulong))
{
inst.VirtualText_value(ulong);
}
if (processinst->GetVirtualData(ulong))
{
inst.VirtualData_value(ulong);
}
if (processinst->GetVirtualStack(ulong))
{
inst.VirtualStack_value(ulong);
}
if (processinst->GetVirtualMemoryMappedFileSize(ulong))
{
inst.VirtualMemoryMappedFileSize_value(ulong);
}
if (processinst->GetVirtualSharedMemory(ulong))
{
inst.VirtualSharedMemory_value(ulong);
}
if (processinst->GetCpuTimeDeadChildren(ulong))
{
inst.CpuTimeDeadChildren_value(ulong);
}
if (processinst->GetSystemTimeDeadChildren(ulong))
{
inst.SystemTimeDeadChildren_value(ulong);
}
if (processinst->GetRealText(ulong))
{
inst.RealText_value(ulong);
}
if (processinst->GetCPUTime(uint))
{
inst.CPUTime_value(uint);
}
if (processinst->GetBlockWritesPerSecond(ulong))
{
inst.BlockWritesPerSecond_value(ulong);
}
if (processinst->GetBlockReadsPerSecond(ulong))
{
inst.BlockReadsPerSecond_value(ulong);
}
if (processinst->GetBlockTransfersPerSecond(ulong))
{
inst.BlockTransfersPerSecond_value(ulong);
}
if (processinst->GetPercentUserTime(ulong))
{
inst.PercentUserTime_value((unsigned char) ulong);
}
if (processinst->GetPercentPrivilegedTime(ulong))
{
inst.PercentPrivilegedTime_value((unsigned char) ulong);
}
if (processinst->GetUsedMemory(ulong))
{
inst.UsedMemory_value(ulong);
}
if (processinst->GetPercentUsedMemory(ulong))
{
inst.PercentUsedMemory_value((unsigned char) ulong);
}
if (processinst->GetPagesReadPerSec(ulong))
{
inst.PagesReadPerSec_value(ulong);
}
}
context.Post(inst);
}