X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Flibesl%2Fesl_oop.cpp;fp=src%2Flibesl%2Fesl_oop.cpp;h=e7168938ca9c85c27c149542bb2633d0193b8256;hb=43715831860b2c1939268c5597bf1f813d3e1fa9;hp=0000000000000000000000000000000000000000;hpb=1440c2126eb1412fed8188472dae93769d2f10ce;p=collectd.git

diff --git a/src/libesl/esl_oop.cpp b/src/libesl/esl_oop.cpp
new file mode 100644
index 00000000..e7168938
--- /dev/null
+++ b/src/libesl/esl_oop.cpp
@@ -0,0 +1,427 @@
+#include <esl.h>
+#include <esl_oop.h>
+
+#define connection_construct_common() memset(&handle, 0, sizeof(handle)); last_event_obj = NULL
+#define event_construct_common() event = NULL; serialized_string = NULL; mine = 0; hp = NULL
+
+void eslSetLogLevel(int level)
+{
+	esl_global_set_default_logger(level);
+}
+
+ESLconnection::ESLconnection(const char *host, const char *port, const char *password)
+{
+	connection_construct_common();
+	int x_port = atoi(port);
+
+	esl_connect(&handle, host, x_port, password);
+}
+
+
+ESLconnection::ESLconnection(int socket)
+{
+	connection_construct_common();
+	memset(&handle, 0, sizeof(handle));
+	esl_attach_handle(&handle, (esl_socket_t)socket, NULL);
+}
+
+ESLconnection::~ESLconnection()
+{
+	if (handle.connected) {
+		esl_disconnect(&handle);
+	}
+
+}
+
+int ESLconnection::disconnect()
+{
+	if (handle.connected) {
+        return esl_disconnect(&handle);
+    }
+
+	return 0;
+}
+
+int ESLconnection::connected()
+{
+	return handle.connected;
+}
+
+int ESLconnection::send(const char *cmd)
+{
+	return esl_send(&handle, cmd);
+}
+
+ESLevent *ESLconnection::sendRecv(const char *cmd)
+{
+	if (esl_send_recv(&handle, cmd) == ESL_SUCCESS) {
+		esl_event_t *event;
+		esl_event_dup(&event, handle.last_sr_event);
+		return new ESLevent(event, 1);
+	}
+	
+	return NULL;
+}
+
+ESLevent *ESLconnection::api(const char *cmd, const char *arg)
+{
+	size_t len;
+	char *cmd_buf;
+	
+	if (!cmd) {
+		return NULL;
+	}
+
+	len = strlen(cmd) + (arg ? strlen(arg) : 0) + 10;
+
+	cmd_buf = (char *) malloc(len + 1);
+	assert(cmd_buf);
+
+	snprintf(cmd_buf, len, "api %s %s", cmd, arg ? arg : "");
+	*(cmd_buf + (len)) = '\0';
+
+
+	if (esl_send_recv(&handle, cmd_buf) == ESL_SUCCESS) {
+		esl_event_t *event;
+		esl_event_dup(&event, handle.last_sr_event);
+		return new ESLevent(event, 1);
+	}
+	
+	free(cmd_buf);
+
+	return NULL;
+}
+
+ESLevent *ESLconnection::bgapi(const char *cmd, const char *arg)
+{
+	size_t len;
+	char *cmd_buf;
+	
+	if (!cmd) {
+		return NULL;
+	}
+
+	len = strlen(cmd) + (arg ? strlen(arg) : 0) + 10;
+
+	cmd_buf = (char *) malloc(len + 1);
+	assert(cmd_buf);
+
+	snprintf(cmd_buf, len, "bgapi %s %s", cmd, arg ? arg : "");
+	*(cmd_buf + (len)) = '\0';
+
+	if (esl_send_recv(&handle, cmd_buf) == ESL_SUCCESS) {
+		esl_event_t *event;
+		esl_event_dup(&event, handle.last_sr_event);
+		return new ESLevent(event, 1);
+	}
+
+	free(cmd_buf);
+	
+	return NULL;
+}
+
+ESLevent *ESLconnection::getInfo()
+{
+	if (handle.connected && handle.info_event) {
+		esl_event_t *event;
+		esl_event_dup(&event, handle.info_event);
+		return new ESLevent(event, 1);
+	}
+	
+	return NULL;
+}
+
+int ESLconnection::setAsyncExecute(const char *val)
+{
+	if (val) {
+		handle.async_execute = esl_true(val);
+	}
+	return handle.async_execute;
+}
+
+int ESLconnection::setEventLock(const char *val)
+{
+	if (val) {
+		handle.event_lock = esl_true(val);
+	}
+	return handle.event_lock;
+}
+
+int ESLconnection::execute(const char *app, const char *arg, const char *uuid)
+{
+	return esl_execute(&handle, app, arg, uuid);
+}
+
+
+int ESLconnection::executeAsync(const char *app, const char *arg, const char *uuid)
+{
+	int async = handle.async_execute;
+	int r;
+
+	handle.async_execute = 1;
+	r = esl_execute(&handle, app, arg, uuid);
+	handle.async_execute = async;
+
+	return r;
+}
+
+int ESLconnection::sendEvent(ESLevent *send_me)
+{
+	return esl_sendevent(&handle, send_me->event);
+}
+
+ESLevent *ESLconnection::recvEvent()
+{
+	if (last_event_obj) {
+		delete last_event_obj;
+	}
+	
+	if (esl_recv_event(&handle, 1, NULL) == ESL_SUCCESS) {
+		esl_event_t *e = handle.last_ievent ? handle.last_ievent : handle.last_event;
+		if (e) {
+			esl_event_t *event;
+			esl_event_dup(&event, e);
+			last_event_obj = new ESLevent(event, 1);
+			return last_event_obj;
+		}
+	}
+
+	last_event_obj = new ESLevent("server_disconnected");
+
+	return last_event_obj;
+}
+
+ESLevent *ESLconnection::recvEventTimed(int ms)
+{
+	if (last_event_obj) {
+		delete last_event_obj;
+		last_event_obj = NULL;
+	}
+
+	if (esl_recv_event_timed(&handle, ms, 1, NULL) == ESL_SUCCESS) {
+		esl_event_t *e = handle.last_ievent ? handle.last_ievent : handle.last_event;
+		if (e) {
+			esl_event_t *event;
+			esl_event_dup(&event, e);
+			last_event_obj = new ESLevent(event, 1);
+			return last_event_obj;
+		}
+    }
+	
+	return NULL;
+}
+
+ESLevent *ESLconnection::filter(const char *header, const char *value)
+{
+	esl_status_t status = esl_filter(&handle, header, value);
+
+	if (status == ESL_SUCCESS && handle.last_sr_event) {
+		esl_event_t *event;
+		esl_event_dup(&event, handle.last_sr_event);
+		return new ESLevent(event, 1);
+	}
+
+	return NULL;
+
+}
+
+int ESLconnection::events(const char *etype, const char *value)
+{
+	esl_event_type_t type_id = ESL_EVENT_TYPE_PLAIN;
+
+	if (!strcmp(etype, "xml")) {
+		type_id = ESL_EVENT_TYPE_XML;
+	}
+
+	return esl_events(&handle, type_id, value);
+}
+
+// ESLevent
+///////////////////////////////////////////////////////////////////////
+
+ESLevent::ESLevent(const char *type, const char *subclass_name)
+{
+	esl_event_types_t event_id;
+	
+	event_construct_common();
+
+	if (esl_name_event(type, &event_id) != ESL_SUCCESS) {
+		event_id = ESL_EVENT_MESSAGE;
+	}
+
+	if (!esl_strlen_zero(subclass_name) && event_id != ESL_EVENT_CUSTOM) {
+		esl_log(ESL_LOG_WARNING, "Changing event type to custom because you specified a subclass name!\n");
+		event_id = ESL_EVENT_CUSTOM;
+	}
+
+	if (esl_event_create_subclass(&event, event_id, subclass_name) != ESL_SUCCESS) {
+		esl_log(ESL_LOG_ERROR, "Failed to create event!\n");
+		event = NULL;
+	}
+
+	serialized_string = NULL;
+	mine = 1;
+}
+
+ESLevent::ESLevent(esl_event_t *wrap_me, int free_me)
+{
+	event_construct_common();
+	event = wrap_me;
+	mine = free_me;
+	serialized_string = NULL;
+}
+
+
+ESLevent::ESLevent(ESLevent *me)
+{
+	/* workaround for silly php thing */
+	event = me->event;
+	mine = me->mine;
+	serialized_string = NULL;
+	me->event = NULL;
+	me->mine = 0;
+	esl_safe_free(me->serialized_string);
+}
+
+ESLevent::~ESLevent()
+{
+	
+	if (serialized_string) {
+		free(serialized_string);
+	}
+
+	if (event && mine) {
+		esl_event_destroy(&event);
+	}
+}
+
+const char *ESLevent::nextHeader(void)
+{
+	const char *name = NULL;
+
+	if (hp) {
+		name = hp->name;
+		hp = hp->next;
+	}
+
+	return name;
+}
+
+const char *ESLevent::firstHeader(void)
+{
+	if (event) {
+		hp = event->headers;
+	}
+
+	return nextHeader();
+}
+
+const char *ESLevent::serialize(const char *format)
+{
+	this_check("");
+
+	esl_safe_free(serialized_string);
+	
+	if (!event) {
+		return "";
+	}
+
+	if (esl_event_serialize(event, &serialized_string, ESL_TRUE) == ESL_SUCCESS) {
+		return serialized_string;
+	}
+
+	return "";
+
+}
+
+bool ESLevent::setPriority(esl_priority_t priority)
+{
+	this_check(false);
+
+	if (event) {
+        esl_event_set_priority(event, priority);
+		return true;
+	} else {
+		esl_log(ESL_LOG_ERROR, "Trying to setPriority an event that does not exist!\n");
+    }
+	return false;
+}
+
+const char *ESLevent::getHeader(const char *header_name)
+{
+	this_check("");
+
+	if (event) {
+		return esl_event_get_header(event, header_name);
+	} else {
+		esl_log(ESL_LOG_ERROR, "Trying to getHeader an event that does not exist!\n");
+	}
+	return NULL;
+}
+
+bool ESLevent::addHeader(const char *header_name, const char *value)
+{
+	this_check(false);
+
+	if (event) {
+		return esl_event_add_header_string(event, ESL_STACK_BOTTOM, header_name, value) == ESL_SUCCESS ? true : false;
+	} else {
+		esl_log(ESL_LOG_ERROR, "Trying to addHeader an event that does not exist!\n");
+	}
+
+	return false;
+}
+
+bool ESLevent::delHeader(const char *header_name)
+{
+	this_check(false);
+
+	if (event) {
+		return esl_event_del_header(event, header_name) == ESL_SUCCESS ? true : false;
+	} else {
+		esl_log(ESL_LOG_ERROR, "Trying to delHeader an event that does not exist!\n");
+	}
+
+	return false;
+}
+
+
+bool ESLevent::addBody(const char *value)
+{
+	this_check(false);
+
+	if (event) {
+		return esl_event_add_body(event, "%s", value) == ESL_SUCCESS ? true : false;
+	} else {
+		esl_log(ESL_LOG_ERROR, "Trying to addBody an event that does not exist!\n");
+	}
+	
+	return false;
+}
+
+char *ESLevent::getBody(void)
+{
+	
+	this_check((char *)"");
+
+	if (event) {
+		return esl_event_get_body(event);
+	} else {
+		esl_log(ESL_LOG_ERROR, "Trying to getBody an event that does not exist!\n");
+	}
+	
+	return NULL;
+}
+
+const char *ESLevent::getType(void)
+{
+	this_check("");
+
+	if (event) {
+		return esl_event_name(event->event_id);
+	} else {
+		esl_log(ESL_LOG_ERROR, "Trying to getType an event that does not exist!\n");
+	}
+	
+	return (char *) "invalid";
+}