172 lines
4.3 KiB
C++
172 lines
4.3 KiB
C++
/*
|
|
PIP - Platform Independent Primitives
|
|
Introspection module - Base server structs
|
|
Ivan Pelipenko peri4ko@yandex.ru
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "piintrospection_server_p.h"
|
|
#include "pichunkstream.h"
|
|
#include "piinit.h"
|
|
#include "pisysteminfo.h"
|
|
#include "piobject.h"
|
|
|
|
|
|
const uint PIIntrospection::sign = 0x0F1C2B3A;
|
|
|
|
|
|
PIIntrospection::RequiredInfo::RequiredInfo() {
|
|
types = itInfo;
|
|
}
|
|
|
|
|
|
PIIntrospection::ProcessInfo::ProcessInfo() {
|
|
processorsCount = 0;
|
|
}
|
|
|
|
|
|
PIIntrospection::ObjectInfo::ObjectInfo() {
|
|
queued_events = 0;
|
|
}
|
|
|
|
|
|
PIIntrospection::ProcessInfo PIIntrospection::getInfo() {
|
|
PIIntrospection::ProcessInfo ret;
|
|
PISystemInfo * si = PISystemInfo::instance();
|
|
ret.architecture = si->architecture;
|
|
ret.execCommand = si->execCommand;
|
|
ret.execDateTime = si->execDateTime;
|
|
ret.hostname = si->hostname;
|
|
ret.OS_name = si->OS_name;
|
|
ret.OS_version = si->OS_version;
|
|
ret.processorsCount = si->processorsCount;
|
|
ret.user = si->user;
|
|
ret.build_options = PIInit::buildOptions();
|
|
return ret;
|
|
}
|
|
|
|
|
|
PIVector<PIIntrospection::ObjectInfo> PIIntrospection::getObjects() {
|
|
PIVector<PIIntrospection::ObjectInfo> ret;
|
|
PIObject::mutexObjects().lock();
|
|
const PIVector<PIObject * > & ao(PIObject::objects());
|
|
ret.resize(ao.size());
|
|
for (int i = 0; i < ao.size_s(); ++i) {
|
|
ret[i].classname = PIStringAscii(ao[i]->className());
|
|
ret[i].name = ao[i]->name();
|
|
//ret[i].properties = ao[i]->properties();
|
|
ret[i].parents = ao[i]->scopeList();
|
|
ao[i]->mutex_queue.lock();
|
|
ret[i].queued_events = ao[i]->events_queue.size_s();
|
|
ao[i]->mutex_queue.unlock();
|
|
}
|
|
PIObject::mutexObjects().unlock();
|
|
return ret;
|
|
}
|
|
|
|
|
|
|
|
|
|
PIByteArray PIIntrospection::packInfo() {
|
|
PIByteArray ret;
|
|
ret << getInfo();
|
|
return ret;
|
|
}
|
|
|
|
|
|
void PIIntrospection::unpackInfo(PIByteArray & ba, PIIntrospection::ProcessInfo & info) {
|
|
ba >> info;
|
|
}
|
|
|
|
|
|
PIByteArray PIIntrospection::packProcStat(PISystemMonitor * sm) {
|
|
ProcessStat ps;
|
|
if (sm) {
|
|
ps.proc = sm->statistic();
|
|
ps.threads = sm->threadsStatistic();
|
|
}
|
|
PIByteArray ret;
|
|
ret << ps.proc << ps.threads;
|
|
return ret;
|
|
}
|
|
|
|
|
|
void PIIntrospection::unpackProcStat(PIByteArray & ba, PIIntrospection::ProcessStat & info) {
|
|
ba >> info.proc >> info.threads;
|
|
}
|
|
|
|
|
|
PIByteArray PIIntrospection::packContainers() {
|
|
PIByteArray ret;
|
|
PIVector<PIIntrospectionContainers::TypeInfo> data;
|
|
PIIntrospectionContainers * p = 0;
|
|
#ifdef PIP_INTROSPECTION
|
|
p = PIINTROSPECTION_CONTAINERS->p;
|
|
#endif
|
|
if (p) {
|
|
data = p->getInfo();
|
|
}
|
|
ret << data;
|
|
return ret;
|
|
}
|
|
|
|
|
|
void PIIntrospection::unpackContainers(PIByteArray & ba, PIVector<PIIntrospectionContainers::TypeInfo> & data) {
|
|
data.clear();
|
|
ba >> data;
|
|
}
|
|
|
|
|
|
PIByteArray PIIntrospection::packThreads() {
|
|
PIByteArray ret;
|
|
PIIntrospectionThreads * p = 0;
|
|
#ifdef PIP_INTROSPECTION
|
|
p = PIINTROSPECTION_THREADS->p;
|
|
#endif
|
|
if (p) {
|
|
p->mutex.lock();
|
|
PIMap<PIThread*, PIIntrospectionThreads::ThreadInfo> & tm(p->threads);
|
|
auto it = tm.makeIterator();
|
|
while (it.next()) {
|
|
it.valueRef().classname = PIStringAscii(it.key()->className());
|
|
it.valueRef().name = it.key()->name();
|
|
}
|
|
ret << tm.values();
|
|
p->mutex.unlock();
|
|
} else {
|
|
ret << PIVector<PIIntrospectionThreads::ThreadInfo>();
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
void PIIntrospection::unpackThreads(PIByteArray & ba, PIVector<PIIntrospectionThreads::ThreadInfo> & threads) {
|
|
threads.clear();
|
|
ba >> threads;
|
|
}
|
|
|
|
|
|
PIByteArray PIIntrospection::packObjects() {
|
|
PIByteArray ret;
|
|
ret << getObjects();
|
|
return ret;
|
|
}
|
|
|
|
|
|
void PIIntrospection::unpackObjects(PIByteArray & ba, PIVector<PIIntrospection::ObjectInfo> & objects) {
|
|
objects.clear();
|
|
ba >> objects;
|
|
}
|