lwtarantool 0.0.2

data/ext/lwtarantool/vendor/msgpuck/test/test.c

@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2010-2016 Tarantool AUTHORS:
+ * please see AUTHORS file in tarantool/tarantool repository.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above
+ *    copyright notice, this list of conditions and the
+ *    following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above
+ *    copyright notice, this list of conditions and the following
+ *    disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+ * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "test.h"
+
+#include <stdio.h>
+#include <stdarg.h>
+
+enum { MAX_LEVELS = 10 };
+static int tests_done[MAX_LEVELS];
+static int tests_failed[MAX_LEVELS];
+static int plan_test[MAX_LEVELS];
+static int level = -1;
+
+void
+__space(FILE *stream)
+{
+	for (int i = 0 ; i < level; i++) {
+		fprintf(stream, "    ");
+	}
+}
+
+void
+plan(int count)
+{
+	++level;
+	plan_test[level] = count;
+	tests_done[level] = 0;
+	tests_failed[level] = 0;
+
+	__space(stdout);
+	printf("%d..%d\n", 1, plan_test[level]);
+}
+
+int
+check_plan(void)
+{
+	int r = 0;
+	if (tests_done[level] != plan_test[level]) {
+		__space(stderr);
+		fprintf(stderr,
+			"# Looks like you planned %d tests but ran %d.\n",
+			plan_test[level], tests_done[level]);
+		r = -1;
+	}
+
+	if (tests_failed[level]) {
+		__space(stderr);
+		fprintf(stderr,
+			"# Looks like you failed %d test of %d run.\n",
+			tests_failed[level], tests_done[level]);
+		r = tests_failed[level];
+	}
+	--level;
+	if (level >= 0) {
+		is(r, 0, "subtests");
+	}
+	return r;
+}
+
+int
+__ok(int condition, const char *fmt, ...)
+{
+	va_list ap;
+
+	__space(stdout);
+	printf("%s %d - ", condition ? "ok" : "not ok", ++tests_done[level]);
+	if (!condition)
+		tests_failed[level]++;
+	va_start(ap, fmt);
+	vprintf(fmt, ap);
+	printf("\n");
+	va_end(ap);
+	return condition;
+}
+

data/ext/lwtarantool/vendor/msgpuck/test/test.h

@@ -0,0 +1,123 @@
+/*
+ * Copyright (C) 2010-2016 Tarantool AUTHORS:
+ * please see AUTHORS file in tarantool/tarantool repository.
+ *
+ * Redistribution and use in source and binary forms, with or
+ * without modification, are permitted provided that the following
+ * conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above
+ *    copyright notice, this list of conditions and the
+ *    following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above
+ *    copyright notice, this list of conditions and the following
+ *    disclaimer in the documentation and/or other materials
+ *    provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+ * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef TEST_H_INCLUDED
+#define TEST_H_INCLUDED
+
+#include <stdio.h>
+
+/**
+@brief example
+
+@code
+	#include "test.h"
+
+	int main(void) {
+		plan(3);		// count of test You planned to check
+		ok(1, "Test name 1");
+		is(4, 2 * 2, "2 * 2 == 4");
+		isnt(5, 2 * 2, "2 * 2 != 5);
+		return check_plan();	// print resume
+	}
+@endcode
+
+
+*/
+
+/* private function, use ok(...) instead */
+int __ok(int condition, const char *fmt, ...);
+
+/* private function, use note(...) or diag(...) instead */
+void __space(FILE *stream);
+
+#define msg(stream, ...) ({ __space(stream); fprintf(stream, "# ");            \
+	fprintf(stream, __VA_ARGS__); fprintf(stream, "\n"); })
+
+#define note(...) msg(stdout, __VA_ARGS__)
+#define diag(...) msg(stderr, __VA_ARGS__)
+
+/**
+@brief set and print plan
+@param count
+Before anything else, you need a testing plan.  This basically declares
+how many tests your program is going to run to protect against premature
+failure.
+*/
+void plan(int count);
+
+/**
+@brief check if plan is reached and print report
+*/
+int check_plan(void);
+
+#define ok(condition, fmt, args...)	{		\
+	int res = __ok(condition, fmt, ##args);		\
+	if (!res) {					\
+		__space(stderr);			\
+		fprintf(stderr, "#   Failed test '");	\
+		fprintf(stderr, fmt, ##args);		\
+		fprintf(stderr, "'\n");			\
+		__space(stderr);			\
+		fprintf(stderr, "#   in %s at line %d\n", __FILE__, __LINE__); \
+	}						\
+}
+
+#define is(a, b, fmt, args...)	{			\
+	int res = __ok((a) == (b), fmt, ##args);	\
+	if (!res) {					\
+		__space(stderr);			\
+		fprintf(stderr, "#   Failed test '");	\
+		fprintf(stderr, fmt, ##args);		\
+		fprintf(stderr, "'\n");			\
+		__space(stderr);			\
+		fprintf(stderr, "#   in %s at line %d\n", __FILE__, __LINE__); \
+	}						\
+}
+
+#define isnt(a, b, fmt, args...) {			\
+	int res = __ok((a) != (b), fmt, ##args);	\
+	if (!res) {					\
+		__space(stderr);			\
+		fprintf(stderr, "#   Failed test '");	\
+		fprintf(stderr, fmt, ##args);		\
+		fprintf(stderr, "'\n");			\
+		__space(stderr);			\
+		fprintf(stderr, "#   in %s at line %d\n", __FILE__, __LINE__); \
+	}						\
+}
+
+#define fail(fmt, args...)		\
+	ok(0, fmt, ##args)
+
+
+#endif /* TEST_H_INCLUDED */
+

data/ext/lwtarantool/vendor/tarantool-c/CMakeLists.txt

@@ -0,0 +1,89 @@
+cmake_minimum_required(VERSION 2.8)
+
+project(LIBTNT)
+
+include(FindPackageMessage)
+
+set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
+set(CMAKE_INCLUDE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake" ${CMAKE_INCLUDE_PATH})
+
+if(POLICY CMP0037)
+    cmake_policy(SET CMP0037 OLD) # don't blame custom target names
+endif(POLICY CMP0037)
+
+set(ENABLE_BUNDLED_MSGPUCK_DEFAULT OFF)
+if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/third_party/msgpuck/CMakeLists.txt)
+    set(ENABLE_BUNDLED_MSGPUCK_DEFAULT ON)
+endif ()
+option(ENABLE_BUNDLED_MSGPUCK "Enable building with the bundled msgpuck"
+       ${ENABLE_BUNDLED_MSGPUCK_DEFAULT})
+
+set(ENABLE_BUNDLED_DOCS_DEFAULT ON)
+option(ENABLE_BUNDLED_DOCS "Enable building bundled docs with doxygen"
+       ${ENABLE_BUNDLED_DOCS_DEFAULT})
+
+if (NOT ENABLE_BUNDLED_MSGPUCK)
+    set (MSGPUCK_REQUIRED ON)
+    include (cmake/FindMsgPuck.cmake)
+    include_directories(${MSGPUCK_INCLUDE_DIR})
+elseif (NOT EXISTS "${PROJECT_SOURCE_DIR}/third_party/msgpuck/msgpuck.h")
+    message(FATAL_ERROR "Could not find msgpuck development files")
+else (NOT ENABLE_BUNDLED_MSGPUCK)
+    set (MSGPUCK_INCLUDE_DIR "${PROJECT_SOURCE_DIR}/third_party")
+    set (MSGPUCK_LIBRARIES msgpuck)
+    set (MSGPUCK_FOUND TRUE)
+    add_subdirectory(third_party/msgpuck)
+endif (NOT ENABLE_BUNDLED_MSGPUCK)
+
+# include_directories("${PROJECT_SOURCE_DIR}/tnt")
+# include_directories("${PROJECT_SOURCE_DIR}/tntnet")
+
+# set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -pthread -Wall -Wextra -std=gnu99 -D__USE_XOPEN")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -std=gnu99 -D__USE_XOPEN")
+set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS} -O0 -g3 -ggdb3")
+set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS} -O2 -g")
+
+if(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE Debug CACHE STRING
+        "Choose the type of build, options are: Debug Release" FORCE)
+endif()
+
+if (ENABLE_BUNDLED_DOCS)
+    add_custom_target (doc COMMAND doxygen ${PROJECT_SOURCE_DIR}/Doxyfile)
+endif(ENABLE_BUNDLED_DOCS)
+
+option(ENABLE_BUNDLED_MSGPUCK "Enable building of the bundled MsgPuck" ON)
+if (ENABLE_BUNDLED_MSGPUCK)
+    set(MSGPUCK_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/third_party/msgpuck)
+    find_package_message(MsgPuck "Using bundled MsgPuck" "${MSGPUCK_INCLUDE_DIRS}")
+else()
+    set(MsgPuck_FIND_REQUIRED ON)
+    find_package(MsgPuck)
+endif()
+
+include_directories("${MSGPUCK_INCLUDE_DIRS}")
+include_directories("${PROJECT_SOURCE_DIR}/third_party")
+include_directories("${PROJECT_SOURCE_DIR}/include")
+
+if (ENABLE_BUNDLED_DOCS)
+    add_subdirectory(doc)
+endif(ENABLE_BUNDLED_DOCS)
+
+message(STATUS "------------------------------------------------")
+message(STATUS "        Tarantool library configuration:        ")
+message(STATUS "------------------------------------------------")
+message(STATUS "  CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}")
+message(STATUS "  PREFIX: ${CMAKE_INSTALL_PREFIX}")
+message(STATUS "  C_COMPILER: ${CMAKE_C_COMPILER}")
+message(STATUS "  C_FLAGS:${CMAKE_C_FLAGS}")
+message(STATUS "------------------------------------------------")
+
+add_subdirectory (include)
+add_subdirectory (tnt)
+#add_subdirectory(tntrpl)
+
+if   (NOT DEFINED TARANTOOL_C_EMBEDDED)
+    add_subdirectory(test)
+endif(NOT DEFINED TARANTOOL_C_EMBEDDED)
+
+message(STATUS "------------------------------------------------")

data/ext/lwtarantool/vendor/tarantool-c/cmake/FindMsgPuck.cmake

@@ -0,0 +1,18 @@
+# - Find libmsgpuck header-only library
+# The module defines the following variables:
+#
+#  MSGPUCK_FOUND - true if MsgPuck was found
+#  MSGPUCK_INCLUDE_DIRS - the directory of the MsgPuck headers
+#  MSGPUCK_LIBRARIES - the MsgPuck static library needed for linking
+#
+
+find_path(MSGPUCK_INCLUDE_DIR msgpuck.h PATH_SUFFIXES msgpuck)
+find_library(MSGPUCK_LIBRARY NAMES libmsgpuck.a)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(MsgPuck
+    REQUIRED_VARS MSGPUCK_INCLUDE_DIR MSGPUCK_LIBRARY)
+set(MSGPUCK_INCLUDE_DIRS ${MSGPUCK_INCLUDE_DIR})
+set(MSGPUCK_LIBRARIES ${MSGPUCK_LIBRARY})
+mark_as_advanced(MSGPUCK_INCLUDE_DIR MSGPUCK_INCLUDE_DIRS
+                 MSGPUCK_LIBRARY MSGPUCK_LIBRARIES)

data/ext/lwtarantool/vendor/tarantool-c/cmake/FindSphinx.cmake

@@ -0,0 +1,10 @@
+include(FindPackageHandleStandardArgs)
+
+find_program(SPHINX_EXECUTABLE NAMES sphinx-build
+    HINTS
+    $ENV{SPHINX_DIR}
+    PATH_SUFFIXES bin
+)
+
+find_package_handle_standard_args(Sphinx DEFAULT_MSG SPHINX_EXECUTABLE)
+mark_as_advanced(SPHINX_EXECUTABLE)

data/ext/lwtarantool/vendor/tarantool-c/doc/CMakeLists.txt

@@ -0,0 +1,15 @@
+find_package(Sphinx)
+
+set(SPHINX_BUILD_HTML_DIR "${PROJECT_BINARY_DIR}/doc/_build/html")
+set(SPHINX_HTML_DIR       "${PROJECT_BINARY_DIR}/output/")
+
+if    (NOT Sphinx-NOTFOUND)
+    add_custom_target(sphinx-html
+        COMMAND "${SPHINX_EXECUTABLE}"
+            -b html
+            -d "${SPHINX_BUILD_HTML_DIR}"
+            "${PROJECT_SOURCE_DIR}/doc/source"
+            "${SPHINX_HTML_DIR}"
+        COMMENT "Building HTML documentation with Sphinx"
+    )
+endif ()

data/ext/lwtarantool/vendor/tarantool-c/doc/source/example.c

@@ -0,0 +1,340 @@
+#define TARANTOOL_URI "localhost:3301"
+#define BUFFER_SIZE   256*1024
+
+#define log_error(fmt, ...)  fprintf(stderr, "%s:%d E>" fmt, __func__, __LINE__, ##__VA_ARGS__)
+
+#include <assert.h>
+#include <stddef.h>
+#include <sys/types.h>
+#include <stdio.h>
+#include <inttypes.h>
+
+#include <tarantool/tarantool.h>
+#include <tarantool/tnt_net.h>
+#include <tarantool/tnt_opt.h>
+#include <msgpuck.h>
+
+int
+tnt_request_set_sspace(struct tnt_stream *tnt, struct tnt_request *req,
+		       const char *space)
+{
+	assert(tnt && space);
+	int32_t sno = tnt_get_spaceno(tnt, space, strlen(space));
+	if (sno == -1)
+		return -1;
+	return tnt_request_set_space(req, sno);
+}
+
+int
+tnt_request_set_sindex(struct tnt_stream *tnt, struct tnt_request *req,
+		       const char *index)
+{
+	assert(tnt && index && req->space_id);
+	int32_t ino = tnt_get_indexno(tnt, req->space_id, index, strlen(index));
+	if (ino == -1)
+		return -1;
+	return tnt_request_set_index(req, ino);
+}
+
+int profile_space_no;
+
+struct msg_profile {
+	int id;
+	char *user;
+	int like;
+	char *msg;
+};
+
+struct tnt_stream *tarantool_connection(const char *uri) {
+	struct tnt_stream *connection = tnt_net(NULL);
+	if (tnt_set(connection, TNT_OPT_URI, uri) == -1)
+		goto rollback;
+	tnt_set(connection, TNT_OPT_SEND_BUF, BUFFER_SIZE);
+	tnt_set(connection, TNT_OPT_RECV_BUF, BUFFER_SIZE);
+	if (tnt_connect(connection) == -1) {
+		log_error("Failed to connect (%s)", tnt_strerror(connection));
+		goto rollback;
+	}
+	return connection;
+rollback:
+	tnt_stream_free(connection);
+	return NULL;
+}
+
+void msg_profile_free(struct msg_profile *msg) {
+	if (msg) {
+		free(msg->msg);
+		free(msg->user);
+		free(msg);
+	}
+}
+
+int msg_profile_decode(struct tnt_reply *rpl, struct msg_profile **rv) {
+	uint32_t str_len = 0;
+	if (rpl->code != 0) {
+		log_error("Query error %d: %.*s", (int )TNT_REPLY_ERR(rpl),
+			  (int )(rpl->error_end - rpl->error), rpl->error);
+		return -1;
+	}
+	if (mp_typeof(*rpl->data) != MP_ARRAY) {
+		log_error("Bad reply format");
+		return -1;
+	} else if (mp_decode_array(&rpl->data) == 0) {
+		return 0;
+	} else if (mp_decode_array(&rpl->data) > 0) {
+		log_error("Bad reply format");
+		return -1;
+	}
+	struct msg_profile *profile = malloc(sizeof(struct msg_profile));
+	if (profile == NULL) {
+		log_error("OOM");
+		return -1;
+	}
+	const char *data = rpl->data;
+	if (mp_typeof(*data) != MP_ARRAY) {
+		log_error("Bad reply format");
+		goto rollback;
+	}
+	uint32_t len = mp_decode_array(&data);
+	if (len < 2) {
+		log_error("Bad reply format");
+		goto rollback;
+	}
+	if (mp_typeof(*data) != MP_UINT) {
+		log_error("Bad reply format");
+		goto rollback;
+	}
+	profile->id = mp_decode_uint(&data);
+	if (mp_typeof(*data) != MP_STR) {
+		log_error("Bad reply format");
+		goto rollback;
+	}
+	profile->user = (char *)mp_decode_str(&data, &str_len);
+	profile->user = strndup(profile->user, str_len);
+	if (profile->user == NULL) {
+		log_error("OOM");
+		goto rollback;
+	}
+	if (mp_typeof(*data) != MP_UINT) {
+		log_error("Bad reply format");
+		goto rollback;
+	}
+	profile->like = mp_decode_uint(&data);
+	if (mp_typeof(*data) != MP_STR) {
+		log_error("Bad reply format");
+		goto rollback;
+	}
+	profile->msg = (char *)mp_decode_str(&data, &str_len);
+	profile->msg = strndup(profile->msg, str_len);
+	if (profile->msg == NULL) {
+		log_error("OOM");
+		goto rollback;
+	}
+	len -= 4;
+	while (len > 0) mp_next(&data);
+	rpl->data = data;
+	*rv = profile;
+	return 0;
+rollback:
+	msg_profile_free(profile);
+	*rv = NULL;
+	return -1;
+}
+
+int msg_profile_get(struct tnt_stream *tnt, int id, struct msg_profile **rv) {
+	static struct tnt_stream *obj = NULL;
+	static struct tnt_reply  *rpl = NULL;
+	if (!obj) {
+		obj = tnt_object(NULL);
+		if (!obj) return -1;
+	}
+	if (!rpl) {
+		rpl = tnt_reply_init(NULL);
+		if (!rpl) return -1;
+	}
+	tnt_object_reset(obj);
+	tnt_object_add_array(obj, 1);
+	tnt_object_add_int(obj, id);
+	if (tnt_select(tnt, profile_space_no, 0, UINT32_MAX, 0, 0, obj) == -1) {
+		log_error("Failed to append request");
+		return -1;
+	}
+	if (tnt_flush(tnt) == -1) {
+		log_error("Failed to send request (%s)", tnt_strerror(tnt));
+		return -1;
+	}
+	if (tnt->read_reply(tnt, rpl) == -1) {
+		log_error("Failed to recv/parse result");
+		if (tnt_error(tnt)) log_error("%s", tnt_strerror(tnt));
+		return -1;
+	}
+	return msg_profile_decode(rpl, rv);
+}
+
+int msg_profile_get_multi(struct tnt_stream *tnt, int *id, size_t cnt,
+			  struct msg_profile ***rv) {
+	static struct tnt_request *req = NULL;
+	if (!req) {
+		req = tnt_request_select(req);
+		tnt_request_set_sspace(tnt, req, "messages");
+		tnt_request_set_sindex(tnt, req, "primary");
+		if (!req) return -1;
+	}
+	for (int i = 0; i < cnt; ++i) {
+		tnt_request_set_key_format(req, "[%d]", id[i]);
+		if (tnt_request_compile(tnt, req) == -1) {
+			log_error("OOM");
+			return -1;
+		}
+	}
+	if (tnt_flush(tnt) == -1) {
+		log_error("Failed to send result (%s)", tnt_strerror(tnt));
+		return -1;
+	}
+	struct msg_profile **retval = calloc(cnt + 1, sizeof(struct msg_profile *));
+	size_t rcvd = 0; retval[cnt] = NULL;
+	struct tnt_iter it; tnt_iter_reply(NULL, tnt);
+	while (tnt_next(&it)) {
+		int rv = msg_profile_decode(TNT_IREPLY_PTR(&it), &retval[rcvd]);
+		if (retval[rcvd] != NULL) ++rcvd;
+		if (rv == -1) {
+			for (int i = 0; i < rcvd; i++)
+				msg_profile_free(retval[rcvd]);
+			free(retval);
+			while (tnt_next(&it));
+			return -1;
+		}
+	}
+	*rv = retval;
+	return rcvd;
+}
+
+int msg_profile_like_add(struct tnt_stream *tnt, int id) {
+	static struct tnt_request *req = NULL;
+	static struct tnt_stream  *obj = NULL;
+	static struct tnt_reply   *rpl = NULL;
+	size_t str_len = 0;
+	if (!obj) {
+		obj = tnt_update_container(NULL);
+		if (obj == NULL) {
+			log_error("OOM");
+			return -1;
+		}
+		/* update like counter and prepend 'liked ' to msg */
+		if (tnt_update_arith_int(obj, 2, '+', 1) == -1 ||
+		    tnt_update_splice(obj, 3, 0, 0, "liked ", 6) == -1) {
+			log_error("OOM");
+			return -1;
+		}
+		tnt_update_container_close(obj);
+	}
+	if (!req) {
+		req = tnt_request_update(req);
+		tnt_request_set_sspace(tnt, req, "messages");
+		tnt_request_set_sindex(tnt, req, "primary");
+		tnt_request_set_tuple(req, obj);
+		if (!req) return -1;
+	}
+	if (!rpl) {
+		rpl = tnt_reply_init(NULL);
+		if (!rpl) return -1;
+	}
+	tnt_request_set_key_format(req, "[%d]", id);
+	if (tnt_request_compile(tnt, req) == -1) {
+		log_error("OOM");
+		return -1;
+	}
+	if (tnt_flush(tnt) == -1) {
+		log_error("Failed to send request (%s)", tnt_strerror(tnt));
+		return -1;
+	}
+	if (tnt->read_reply(tnt, rpl) == -1) {
+		log_error("Failed to recv/parse result");
+		if (tnt_error(tnt)) log_error("%s", tnt_strerror(tnt));
+		return -1;
+	}
+	if (rpl->code) {
+		log_error("Query error %d: %.*s", (int )TNT_REPLY_ERR(rpl),
+			  (int )(rpl->error_end - rpl->error), rpl->error);
+		return -1;
+	}
+	return 0;
+}
+
+int msg_profile_create(struct tnt_request *req, int id, const char *usr,
+		       size_t usr_len, int likes, const char *msg, size_t msg_len) {
+	if (tnt_request_set_tuple_format(req, "[%d%.*s%d%.*s]", id, usr_len,
+					 usr, likes, msg_len, msg) == -1) {
+		return -1;
+	}
+	return 0;
+}
+
+int msg_profile_create_alt(struct tnt_stream *obj, int id, const char *usr,
+			   size_t usr_len, int likes, const char *msg,
+			   size_t msg_len) {
+	if (tnt_object_add_array(obj, 4) == -1 ||
+	    tnt_object_add_int(obj, id) == -1 ||
+	    tnt_object_add_str(obj, usr, usr_len) == -1 ||
+	    tnt_object_add_int(obj, likes) == -1 ||
+	    tnt_object_add_str(obj, msg, msg_len) == -1) {
+		log_error("OOM");
+		return -1;
+	}
+	return 0;
+}
+
+int msg_profile_put(struct tnt_stream *tnt, int id, const char *usr,
+		    size_t usr_len, int likes, const char *msg, size_t msg_len) {
+	static struct tnt_request *req = NULL;
+	static struct tnt_reply   *rpl = NULL;
+	if (!req) {
+		req = tnt_request_update(req);
+		if (!req) return -1;
+		if (tnt_request_set_sspace(tnt, req, "messages") == -1) {
+			log_error("failed to find space 'messages'");
+			return -1;
+		}
+		if (tnt_request_set_sindex(tnt, req, "primary") == -1) {
+			log_error("failed to find index 'primary' in space "
+				  "'message'");
+			return -1;
+		}
+	}
+	if (msg_profile_create(req, id, usr, usr_len, likes, msg, msg_len) == -1) {
+		log_error("OOM");
+		return -1;
+	}
+	if (tnt_request_set_tuple_format(req, "[%d%.*s%d%.*s]", id, usr_len,
+					 usr, likes, msg_len, msg) == -1) {
+		log_error("OOM");
+		return -1;
+	}
+	if (tnt_request_compile(tnt, req) == -1) {
+		log_error("OOM");
+		return -1;
+	}
+	if (tnt_flush(tnt) == -1) {
+		log_error("Failed to send request (%s)", tnt_strerror(tnt));
+		return -1;
+	}
+	if (tnt->read_reply(tnt, rpl) == -1) {
+		log_error("Failed to recv/parse result");
+		if (tnt_error(tnt)) log_error("%s", tnt_strerror(tnt));
+		return -1;
+	}
+	if (rpl->code) {
+		log_error("Query error %d: %.*s", (int )TNT_REPLY_ERR(rpl),
+			  (int )(rpl->error_end - rpl->error), rpl->error);
+		return -1;
+	}
+	return 0;
+}
+
+/* To build this example use next command:
+ * gcc example.c -I ../../include/ -L ../../tnt/ -ltarantool */
+int main() {
+	struct tnt_stream *tnt = tarantool_connection(TARANTOOL_URI);
+	profile_space_no = tnt_get_spaceno(tnt, "messages", strlen("messages"));
+	tnt_stream_free(tnt);
+}

data/ext/lwtarantool/vendor/tarantool-c/include/CMakeLists.txt

@@ -0,0 +1,6 @@
+if(NOT DEFINED CMAKE_INSTALL_INCLUDEDIR)
+    set(CMAKE_INSTALL_INCLUDEDIR include)
+endif(NOT DEFINED CMAKE_INSTALL_INCLUDEDIR)
+
+# installation of tarantool C client library headers
+install(DIRECTORY tarantool DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})