lwtarantool 0.0.2

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

@@ -0,0 +1,36 @@
+set(common_files test.c
+                 common.c
+                 tnt_assoc.c)
+
+project(tarantool-test-tcp)
+add_executable(tarantool-test-tcp
+    tarantool_tcp.c
+    ${common_files})
+set_target_properties(tarantool-test-tcp PROPERTIES OUTPUT_NAME "tarantool-tcp")
+target_link_libraries(tarantool-test-tcp tnt)
+
+project(tarantool-test-unix)
+add_executable(tarantool-test-unix
+    tarantool_unix.c
+    ${common_files})
+set_target_properties(tarantool-test-unix PROPERTIES OUTPUT_NAME "tarantool-unix")
+target_link_libraries(tarantool-test-unix tnt)
+
+project(tarantool-test-disconnect)
+add_executable(tarantool-test-disconnect
+    tarantool_disconnect.c
+    ${common_files})
+set_target_properties(tarantool-test-disconnect PROPERTIES OUTPUT_NAME "tarantool-disconnect")
+target_link_libraries(tarantool-test-disconnect tnt)
+
+project(tarantool-test-call)
+add_executable(tarantool-test-call
+    tarantool_call.c
+    ${common_files})
+set_target_properties(tarantool-test-call PROPERTIES OUTPUT_NAME "tarantool-call")
+target_link_libraries(tarantool-test-call tnt)
+
+add_custom_target(test
+    COMMAND ${PROJECT_SOURCE_DIR}/test-run.py -j -1
+        --builddir=${PROJECT_BINARY_DIR}
+        --vardir=${PROJECT_BINARY_DIR}/test/var)

data/ext/lwtarantool/vendor/tarantool-c/test/common.c

@@ -0,0 +1,233 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <stddef.h>
+
+#include <msgpuck.h>
+
+#include <tarantool/tarantool.h>
+#include <tarantool/tnt_net.h>
+
+#include "common.h"
+#include "tnt_assoc.h"
+
+void
+hex_dump (const char *desc, const char *addr, size_t len) {
+	size_t i;
+	unsigned char buff[17];
+	unsigned char *pc = (unsigned char*)addr;
+
+	if (desc != NULL)
+		printf ("%s:\n", desc);
+	for (i = 0; i < len; i++) {
+		if ((i % 16) == 0) {
+			if (i != 0) printf ("  %s\n", buff);
+			printf ("  %04x ", (unsigned int)i);
+		}
+		printf (" %02x", pc[i]);
+		if ((pc[i] < 0x20) || (pc[i] > 0x7e))
+			buff[i % 16] = '.';
+		else
+			buff[i % 16] = pc[i];
+		buff[(i % 16) + 1] = '\0';
+	}
+	while ((i % 16) != 0) {
+		printf ("   ");
+		i++;
+	}
+	printf ("  %s\n", buff);
+}
+
+void
+hex_dump_c (const char *addr, size_t len) {
+	const char *addr_end = addr + len;
+	size_t n = 0;
+	while (addr < addr_end) {
+		if (n == 0) { printf("\""); n = 14; }
+		printf("\\x%02x", *(unsigned char *)addr);
+		addr += 1; n -= 1;
+		if (n == 0) { printf("\"\n"); }
+	}
+	if (n != 0) { printf("\"\n"); }
+}
+
+static inline void
+mp_dump_hex (const char *addr, size_t len) {
+	const char *addr_end = addr + len;
+	printf("\"");
+	while (addr < addr_end) printf("\\x%02x", *(unsigned char *)addr++);
+	printf("\"");
+}
+
+void
+mp_dump (const char *addr, size_t len) {
+	printf("mp_dump_begin\n  ");
+	const char *addr_end = addr + len;
+	struct mp_dump_stack stack[128];
+	memset(stack, 0, sizeof(struct mp_dump_stack) * 128);
+	size_t stack_size = 0;
+	char begin = 1;
+	while (addr < addr_end) {
+		if (begin) {
+			begin = 0;
+		} else {
+			if (stack_size > 0) {
+				while (stack_size > 0 && stack[stack_size - 1].lft == 0) {
+					switch (stack[stack_size - 1].type) {
+					case (MP_ARRAY):
+						printf("]");
+						break;
+					case (MP_MAP):
+						printf("}");
+						break;
+					default:
+						printf("???");
+					}
+					stack_size -= 1;
+				}
+				if (stack_size > 0 && stack[stack_size - 1].type == MP_MAP) {
+					if (stack[stack_size - 1].lft % 2) {
+						printf(":");
+					} else if (!stack[stack_size - 1].start_flag) {
+						printf(",");
+					}
+					if (!stack[stack_size - 1].start_flag)
+						printf(" ");
+					stack[stack_size - 1].start_flag = 0;
+					stack[stack_size - 1].lft -= 1;
+				}
+			}
+			if (!stack_size) {
+				printf("\n  ");
+			}
+		}
+		switch (mp_typeof(*addr)) {
+		case (MP_NIL):
+			printf("nil");
+			mp_decode_nil(&addr);
+			break;
+		case (MP_UINT):
+			printf("%zd", mp_decode_uint(&addr));
+			break;
+		case (MP_INT):
+			printf("%zd", mp_decode_int(&addr));
+			break;
+		case (MP_STR): {
+			uint32_t str_len = 0;
+			const char *str = mp_decode_str(&addr, &str_len);
+			printf("\"%.*s\"", str_len, str);
+			break;
+		}
+		case (MP_BIN): {
+			uint32_t bin_len = 0;
+			const char *bin = mp_decode_bin(&addr, &bin_len);
+			mp_dump_hex(bin, bin_len);
+			break;
+		}
+		case (MP_ARRAY):
+			stack[stack_size++] = (struct mp_dump_stack){
+				.type = MP_ARRAY,
+				.start_flag = 1,
+				.lft = mp_decode_array(&addr)
+			};
+			printf("[");
+			break;
+		case (MP_MAP):
+			stack[stack_size++] = (struct mp_dump_stack){
+				.type = MP_MAP,
+				.start_flag = 1,
+				.lft = mp_decode_map(&addr) * 2
+			};
+			printf("{");
+			break;
+		case (MP_BOOL):
+			if (mp_decode_bool(&addr)) {
+				printf ("true");
+			} else {
+				printf ("false");
+			}
+			break;
+		case (MP_FLOAT):
+			printf("%f", mp_decode_float(&addr));
+			break;
+		case (MP_DOUBLE):
+			printf("%f", mp_decode_double(&addr));
+			break;
+		case (MP_EXT):
+			printf("ext");
+			mp_next(&addr);
+			break;
+		default:
+			printf("whattheheck");
+			mp_next(&addr);
+		}
+	}
+	while (stack_size > 0 && stack[stack_size - 1].lft == 0) {
+		switch (stack[stack_size - 1].type) {
+		case (MP_ARRAY):
+			printf("]");
+			break;
+		case (MP_MAP):
+			printf("}");
+			break;
+		default:
+			printf("???");
+		}
+		stack_size -= 1;
+	}
+	printf("\n");
+}
+
+int
+check_bbytes(const char *buf, size_t buf_size, const char *bb, size_t bb_size) {
+	if (bb == NULL) goto error;
+	if (buf_size != bb_size) goto error;
+	if (memcmp(buf, bb, bb_size)) goto error;
+	return 0;
+error:
+	if (bb) {
+		hex_dump("expected", bb, bb_size);
+		mp_dump(bb, bb_size);
+	}
+	hex_dump("got", (const char *)buf, buf_size);
+	mp_dump(buf, buf_size);
+	hex_dump_c((const char *)buf, buf_size);
+	return -1;
+}
+
+int
+check_rbytes(struct tnt_reply *s, const char *bb, size_t bb_size) {
+	return check_bbytes(s->buf, s->buf_size, bb, bb_size);
+}
+
+int
+check_sbytes(struct tnt_stream *s, const char *bb, size_t bb_size) {
+	return check_bbytes(TNT_SBUF_DATA(s), TNT_SBUF_SIZE(s), bb, bb_size);
+}
+
+int
+check_nbytes(struct tnt_stream *s, const char *bb, size_t bb_size) {
+	struct tnt_stream_net *sn = TNT_SNET_CAST(s);
+	return check_bbytes(sn->sbuf.buf, sn->sbuf.off, bb, bb_size);
+}
+
+int dump_schema_index(struct tnt_schema_sval *sval) {
+	mh_int_t ipos = 0;
+	mh_foreach(sval->index, ipos) {
+		struct tnt_schema_ival *ival = NULL;
+		ival = (*mh_assoc_node(sval->index, ipos))->data;
+		printf("    %d: %s\n", ival->number, ival->name);
+	}
+	return 0;
+}
+
+int dump_schema(struct tnt_stream *s) {
+	struct mh_assoc_t *schema = (TNT_SNET_CAST(s)->schema)->space_hash;
+	mh_int_t spos = 0;
+	mh_foreach(schema, spos) {
+		struct tnt_schema_sval *sval = NULL;
+		sval = (*mh_assoc_node(schema, spos))->data;
+		printf("  %d: %s\n", sval->number, sval->name);
+		(void )dump_schema_index(sval);
+	}
+	return 0;
+}

data/ext/lwtarantool/vendor/tarantool-c/test/common.h

@@ -0,0 +1,28 @@
+#ifndef _TEST_COMMON_H_
+#define _TEST_COMMON_H_
+
+#include <msgpuck.h>
+
+struct mp_dump_stack {
+	enum mp_type type;
+	char start_flag;
+	size_t lft;
+};
+
+void hex_dump (const char *desc, const char *addr, size_t len);
+void hex_dump_c (const char *addr, size_t len);
+
+void mp_dump (const char *addr, size_t len);
+
+int check_bbytes(const char *buf, size_t buf_size,
+		 const char *bb, size_t bb_size);
+
+int check_rbytes(struct tnt_reply *s,
+		 const char *bb, size_t bb_size);
+int check_sbytes(struct tnt_stream *s,
+		 const char *bb, size_t bb_size);
+int check_nbytes(struct tnt_stream *s,
+		 const char *bb, size_t bb_size);
+int dump_schema(struct tnt_stream *s);
+
+#endif /* _TEST_COMMON_H_ */

data/ext/lwtarantool/vendor/tarantool-c/test/plain_test.c

@@ -0,0 +1,152 @@
+#include <string.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+#include <assert.h>
+#include <stdio.h>
+
+#include <sys/uio.h>
+
+#include <msgpuck/msgpuck.h>
+
+#include <tarantool/tnt_net.h>
+
+void hexDump (char *desc, void *addr, int len) {
+	int i;
+	unsigned char buff[17];
+	unsigned char *pc = (unsigned char*)addr;
+
+	if (desc != NULL)
+		printf ("%s:\n", desc);
+	for (i = 0; i < len; i++) {
+		if ((i % 16) == 0) {
+			if (i != 0) printf ("  %s\n", buff);
+			printf ("  %04x ", i);
+		}
+		printf (" %02x", pc[i]);
+		if ((pc[i] < 0x20) || (pc[i] > 0x7e))
+			buff[i % 16] = '.';
+		else
+			buff[i % 16] = pc[i];
+		buff[(i % 16) + 1] = '\0';
+	}
+	while ((i % 16) != 0) {
+		printf ("   ");
+		i++;
+	}
+	printf ("  %s\n", buff);
+}
+
+int main() {
+	struct tnt_stream *s = tnt_net(NULL);
+	struct tnt_reply r; tnt_reply_init(&r);
+	assert(tnt_set(s, TNT_OPT_URI, "myamlya:1234@/tmp/taran_tool.sock\0") != -1);
+	assert(tnt_connect(s) != -1);
+	assert(tnt_authenticate(s) != -1);
+	assert(tnt_reload_schema(s) != -1);
+	struct tnt_stream *empty = tnt_object(NULL);
+	tnt_object_add_array(empty, 0);
+
+	int rc = tnt_call_16(s, "fiber.time", 10, empty);
+	rc += tnt_eval(s, "fiber.time", 10, empty);
+	hexDump("fiber_time (call+eval)", TNT_SNET_CAST(s)->sbuf.buf, rc);
+	rc = tnt_flush(s);
+	printf("%d\n", rc);
+	printf("%d\n", s->read_reply(s, &r));
+	hexDump("response call", (void *)r.buf, r.buf_size); tnt_reply_free(&r);
+	printf("%d\n", s->read_reply(s, &r));
+	hexDump("response eval", (void *)r.buf, r.buf_size); tnt_reply_free(&r);
+
+	struct tnt_stream *arr = tnt_object(NULL);
+	tnt_object_add_array(arr, 3);
+	tnt_object_add_int(arr, 1);
+	tnt_object_add_int(arr, 2);
+	tnt_object_add_int(arr, 3);
+
+	rc  = tnt_insert(s, 512, arr);
+	rc += tnt_replace(s, 512, arr);
+	hexDump("insert+replace [1,2,3]", TNT_SNET_CAST(s)->sbuf.buf, rc);
+	rc = tnt_flush(s);
+	printf("%d\n", rc);
+	printf("%d\n", s->read_reply(s, &r));
+	hexDump("response insert", (void *)r.buf, r.buf_size); tnt_reply_free(&r);
+	printf("%d\n", s->read_reply(s, &r));
+	hexDump("response replace", (void *)r.buf, r.buf_size); tnt_reply_free(&r);
+
+	rc  = tnt_ping(s);
+	hexDump("ping", TNT_SNET_CAST(s)->sbuf.buf, rc);
+	rc = tnt_flush(s);
+	printf("%d\n", rc);
+	printf("%d\n", s->read_reply(s, &r));
+	hexDump("response ping", (void *)r.buf, r.buf_size); tnt_reply_free(&r);
+
+	struct tnt_stream *key = tnt_object(NULL);
+	tnt_object_add_array(key, 1);
+	tnt_object_add_int(key, 1);
+
+	rc  = tnt_select(s, 512, 0, UINT32_MAX, 0, 0, key);
+	hexDump("select [1]", TNT_SNET_CAST(s)->sbuf.buf, rc);
+	rc = tnt_flush(s);
+	printf("%d\n", rc);
+	printf("%d\n", s->read_reply(s, &r));
+	hexDump("response select", (void *)r.buf, r.buf_size); tnt_reply_free(&r);
+
+	rc  = tnt_delete(s, 512, 0, key);
+	hexDump("delete [1]", TNT_SNET_CAST(s)->sbuf.buf, rc);
+	rc = tnt_flush(s);
+	printf("%d\n", rc);
+	printf("%d\n", s->read_reply(s, &r));
+	hexDump("response delete", (void *)r.buf, r.buf_size); tnt_reply_free(&r);
+
+	rc  = tnt_auth(s, "myamlya", 7, "1234", 4);
+	rc += tnt_deauth(s);
+	rc += tnt_auth(s, "guest", 5, NULL, 0);
+	hexDump("auth No1", TNT_SNET_CAST(s)->sbuf.buf, rc);
+	rc = tnt_flush(s);
+	printf("%d\n", rc);
+	printf("%d\n", s->read_reply(s, &r));
+	hexDump("response auth", (void *)r.buf, r.buf_size); tnt_reply_free(&r);
+	printf("%d\n", s->read_reply(s, &r));
+	hexDump("response deauth", (void *)r.buf, r.buf_size); tnt_reply_free(&r);
+	printf("%d\n", s->read_reply(s, &r));
+	hexDump("response auth deauth", (void *)r.buf, r.buf_size); tnt_reply_free(&r);
+
+	tnt_stream_free(arr);
+	arr = tnt_object(NULL);
+	tnt_object_add_array(arr, 8);
+	tnt_object_add_int(arr, 1);
+	tnt_object_add_int(arr, 2);
+	tnt_object_add_float(arr, 3.0);
+	tnt_object_add_double(arr, 4.0);
+	tnt_object_add_int(arr, 31);
+	tnt_object_add_int(arr, 6);
+	tnt_object_add_strz(arr, "hello, brian");
+	tnt_object_add_int(arr, 1111);
+	hexDump("arr", TNT_SBUF_DATA(arr), TNT_SBUF_SIZE(arr));
+
+	rc = tnt_replace(s, 512, arr);
+	hexDump("replace [1, 2, 3.0F, 4.0D, 5, 6, \"hello, brian\", 1111]", TNT_SNET_CAST(s)->sbuf.buf, rc);
+	rc = tnt_flush(s);
+	printf("%d\n", rc);
+	printf("%d\n", s->read_reply(s, &r));
+	hexDump("response replace", (void *)r.buf, r.buf_size); tnt_reply_free(&r);
+
+	struct tnt_stream *ops = tnt_buf(NULL);
+	assert(tnt_update_arith_int(ops, 1, '+', 10) != -1);
+	assert(tnt_update_arith_float(ops, 2, '+', 3.2) != -1);
+	assert(tnt_update_arith_double(ops, 3, '+', 7.8) != -1);
+	assert(tnt_update_bit(ops, 4, '&', 0x10001) != -1);
+	assert(tnt_update_assign(ops, 8, arr) != -1);
+	assert(tnt_update_splice(ops, 6, 7, 5, "master", 6) != -1);
+	assert(tnt_update_insert(ops, 8, arr) != -1);
+	
+	rc = tnt_update(s, 512, 0, key, ops);
+	hexDump("update", TNT_SNET_CAST(s)->sbuf.buf, rc);
+	rc = tnt_flush(s);
+	printf("%d\n", rc);
+	printf("%d\n", s->read_reply(s, &r));
+	hexDump("response update", (void *)r.buf, r.buf_size); tnt_reply_free(&r);
+
+	return 0;
+}

data/ext/lwtarantool/vendor/tarantool-c/test/tarantool_call.c

@@ -0,0 +1,57 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+
+#include <tarantool/tarantool.h>
+#include <tarantool/tnt_net.h>
+#include <tarantool/tnt_opt.h>
+
+#include "common.h"
+
+int64_t CallTarantoolFunction(struct tnt_stream* stream, const char* name,
+			       const char* format, ...)
+{
+	struct tnt_request* request   = tnt_request_call_16(NULL);
+	struct tnt_stream*  arguments = tnt_object(NULL);
+
+	va_list list;
+	va_start(list, format);
+	tnt_object_vformat(arguments, format, list);
+	va_end(list);
+
+	tnt_request_set_funcz(request, name);
+	tnt_request_set_tuple(request, arguments);
+
+	int64_t result = tnt_request_compile(stream, request);
+
+	tnt_stream_free(arguments);
+	tnt_request_free(request);
+	tnt_flush(stream);
+
+	return result;
+}
+
+int main() {
+	const char * uri = "localhost:3301";
+	struct tnt_stream * tnt = tnt_net(NULL); // Allocating stream
+	tnt_set(tnt, TNT_OPT_URI, uri); // Setting URI
+	tnt_set(tnt, TNT_OPT_SEND_BUF, 0); // Disable buffering for send
+	tnt_set(tnt, TNT_OPT_RECV_BUF, 0); // Disable buffering for recv
+	tnt_connect(tnt);
+	CallTarantoolFunction(tnt, "test_1","[{%s%d%s%s%s%u%s%d%s%d%s%u%s%u%s%llu%s%u}]",
+			      "kind",        110,
+			      "name",        "FastForward",
+			      "number",      2621,
+			      "slot",        0,
+			      "flavor",      7,
+			      "source",      2321040,
+			      "destination", 2321,
+			      "tag",         0,
+			      "network",     2501);
+	struct tnt_reply *reply = tnt_reply_init(NULL); // Initialize reply
+	tnt->read_reply(tnt, reply); // Read reply from server
+
+	check_rbytes(reply, NULL, 0);
+
+	tnt_reply_free(reply); // Free reply
+}

data/ext/lwtarantool/vendor/tarantool-c/test/tarantool_disconnect.c

@@ -0,0 +1,31 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+
+#include <tarantool/tarantool.h>
+#include <tarantool/tnt_net.h>
+#include <tarantool/tnt_opt.h>
+
+int main() {
+	const char * uri = "localhost:3301";
+	struct tnt_stream * tnt = tnt_net(NULL); // Allocating stream
+	tnt_set(tnt, TNT_OPT_URI, uri); // Setting URI
+	tnt_set(tnt, TNT_OPT_SEND_BUF, 0); // Disable buffering for send
+	tnt_set(tnt, TNT_OPT_RECV_BUF, 0); // Disable buffering for recv
+	tnt_connect(tnt);
+
+	while (1) {
+		if (tnt_error(tnt) != TNT_EOK) {
+			printf("disconnected %s\n", tnt_strerror(tnt));
+			tnt_connect(tnt);
+		}
+		printf("next_request\n");
+		tnt_ping(tnt); // Send ping request
+		struct tnt_reply * reply = tnt_reply_init(NULL); // Initialize reply
+		tnt->read_reply(tnt, reply); // Read reply from server
+		tnt_reply_free(reply); // Free reply
+		usleep(1000000);
+	}
+
+	tnt_stream_free(tnt); // Close connection and free stream object
+}