git-svn-id: svn://db.shs.com.ru/pip@803 12ceb7fc-bf1f-11e4-8940-5bc7170c53b5

src_main/introspection/piintrospection_server_p.cpp

@@ -0,0 +1,208 @@
+/*
+    PIP - Platform Independent Primitives
+	Introspection module - Base server structs
+	Copyright (C) 2019  Ivan Pelipenko peri4ko@yandex.ru
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU 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 General Public License for more details.
+
+    You should have received a copy of the GNU 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::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 & operator <<(PIByteArray & s, const std::unordered_map<uint, PIIntrospectionContainers::Type> & v) {
+	PIMap<uint, PIIntrospectionContainers::Type> m;
+	for (typename std::unordered_map<uint, PIIntrospectionContainers::Type>::const_iterator i = v.cbegin(); i != v.cend(); ++i) {
+		m[i->first] = i->second;
+	}
+	s << m;
+	return s;
+}
+
+
+PIByteArray & operator <<(PIByteArray & b, const PIIntrospection::ProcessInfo & v) {
+	PIChunkStream cs;
+	cs.add(1, v.architecture).add(2, v.execCommand).add(3, v.execDateTime).add(4, v.hostname).add(5, v.OS_name)
+	  .add(6, v.OS_version).add(7, v.processorsCount).add(8, v.user).add(9, v.build_options);
+	b << cs.data();
+	return b;
+}
+
+
+PIByteArray & operator >>(PIByteArray & b, PIIntrospection::ProcessInfo & v) {
+	PIByteArray csba; b >> csba;
+	PIChunkStream cs(csba);
+	while (!cs.atEnd()) {
+		switch (cs.read()) {
+		case 1: cs.get(v.architecture); break;
+		case 2: cs.get(v.execCommand); break;
+		case 3: cs.get(v.execDateTime); break;
+		case 4: cs.get(v.hostname); break;
+		case 5: cs.get(v.OS_name); break;
+		case 6: cs.get(v.OS_version); break;
+		case 7: cs.get(v.processorsCount); break;
+		case 8: cs.get(v.user); break;
+		case 9: cs.get(v.build_options); break;
+		default: break;
+		}
+	}
+	return b;
+}
+
+
+PIByteArray & operator <<(PIByteArray & b, const PIIntrospection::ObjectInfo & v) {
+	PIChunkStream cs;
+	cs.add(1, v.classname).add(2, v.name).add(3, v.parents).add(4, v.properties).add(5, v.queued_events);
+	b << cs.data();
+	return b;
+}
+
+
+PIByteArray & operator >>(PIByteArray & b, PIIntrospection::ObjectInfo & v) {
+	PIByteArray csba; b >> csba;
+	PIChunkStream cs(csba);
+	while (!cs.atEnd()) {
+		switch (cs.read()) {
+		case 1: cs.get(v.classname); break;
+		case 2: cs.get(v.name); break;
+		case 3: cs.get(v.parents); break;
+		case 4: cs.get(v.properties); break;
+		case 5: cs.get(v.queued_events); break;
+		default: break;
+		}
+	}
+	return b;
+}
+
+
+
+
+PIByteArray PIIntrospection::packInfo() {
+	PIByteArray ret;
+	ret << getInfo();
+	return ret;
+}
+
+
+void PIIntrospection::unpackInfo(PIByteArray & ba, PIIntrospection::ProcessInfo & info) {
+	ba >> info;
+}
+
+
+PIByteArray PIIntrospection::packContainers() {
+	PIByteArray ret;
+	PIIntrospectionContainers * p = PIINTROSPECTION_CONTAINERS->p;
+	p->mutex.lock();
+	std::unordered_map<uint, PIIntrospectionContainers::Type> data = p->data;
+	std::unordered_map<uint, std::string> typenames = p->typenames;
+	p->mutex.unlock();
+	ret << data << typenames;
+	return ret;
+}
+
+
+void PIIntrospection::unpackContainers(PIByteArray & ba, PIMap<uint, PIIntrospectionContainers::Type> & data, PIMap<uint, PIString> & typenames) {
+	data.clear();
+	typenames.clear();
+	ba >> data >> typenames;
+}
+
+
+PIByteArray PIIntrospection::packThreads() {
+	PIByteArray ret;
+	PIIntrospectionThreads * p = PIINTROSPECTION_THREADS->p;
+	p->mutex.lock();
+	ret << p->threads.values();
+	p->mutex.unlock();
+	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;
+}