lwtarantool 0.0.2

data/ext/lwtarantool/vendor/tarantool-c/tntrpl/tnt_log.h

@@ -0,0 +1,119 @@
+#ifndef TNT_LOG_H_INCLUDED
+#define TNT_LOG_H_INCLUDED
+
+/*
+ * 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.
+ */
+
+#define TNT_LOG_MAGIC_XLOG "XLOG\n"
+#define TNT_LOG_MAGIC_SNAP "SNAP\n"
+#define TNT_LOG_VERSION "0.11\n"
+
+enum tnt_log_error {
+	TNT_LOG_EOK,
+	TNT_LOG_EFAIL,
+	TNT_LOG_EMEMORY,
+	TNT_LOG_ETYPE,
+	TNT_LOG_EVERSION,
+	TNT_LOG_ECORRUPT,
+	TNT_LOG_ESYSTEM,
+	TNT_LOG_LAST
+};
+
+struct tnt_log_header_v11 {
+	uint32_t crc32_hdr;
+	uint64_t lsn;
+	double tm;
+	uint32_t len;
+	uint32_t crc32_data;
+} __attribute__((packed));
+
+struct tnt_log_row_v11 {
+	uint16_t tag;
+	uint64_t cookie;
+	uint16_t op;
+} __attribute__((packed));
+
+struct tnt_log_row_snap_v11 {
+	uint16_t tag;
+	uint64_t cookie;
+	uint32_t space;
+	uint32_t tuple_size;
+	uint32_t data_size;
+} __attribute__((packed));
+
+enum tnt_log_type {
+	TNT_LOG_NONE,
+	TNT_LOG_XLOG,
+	TNT_LOG_SNAPSHOT
+};
+
+union tnt_log_value {
+	struct tnt_request r;
+	struct tnt_tuple t;
+};
+
+struct tnt_log_row {
+	struct tnt_log_header_v11 hdr;
+	struct tnt_log_row_v11 row;
+	struct tnt_log_row_snap_v11 row_snap;
+	union tnt_log_value *value;
+};
+
+struct tnt_log {
+	enum tnt_log_type type;
+	FILE *fd;
+	off_t current_offset;
+	off_t offset;
+	int (*read)(struct tnt_log *l, char **buf, uint32_t *size);
+	int (*process)(struct tnt_log *l, char *buf, uint32_t size,
+		       union tnt_log_value *value);
+	struct tnt_log_row current;
+	union tnt_log_value current_value;
+	enum tnt_log_error error;
+	int errno_;
+};
+
+extern const uint32_t tnt_log_marker_v11;
+extern const uint32_t tnt_log_marker_eof_v11;
+
+enum tnt_log_type tnt_log_guess(char *file);
+
+enum tnt_log_error
+tnt_log_open(struct tnt_log *l, char *file, enum tnt_log_type type);
+int tnt_log_seek(struct tnt_log *l, off_t offset);
+void tnt_log_close(struct tnt_log *l);
+
+struct tnt_log_row *tnt_log_next(struct tnt_log *l);
+struct tnt_log_row *tnt_log_next_to(struct tnt_log *l, union tnt_log_value *value);
+
+enum tnt_log_error tnt_log_error(struct tnt_log *l);
+char *tnt_log_strerror(struct tnt_log *l);
+int tnt_log_errno(struct tnt_log *l);
+
+#endif /* TNT_LOG_H_INCLUDED */

data/ext/lwtarantool/vendor/tarantool-c/tntrpl/tnt_rpl.c

@@ -0,0 +1,189 @@
+
+/*
+ * 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 <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+
+#include <tarantool.h>
+#include <tnt_net.h>
+#include <tnt_io.h>
+#include <tnt_log.h>
+#include <tnt_rpl.h>
+
+static const uint32_t tnt_rpl_version = 11;
+
+static void tnt_rpl_free(struct tnt_stream *s) {
+	struct tnt_stream_rpl *sr = TNT_RPL_CAST(s);
+	if (sr->net) {
+		/* network stream should not be free'd here */
+		sr->net = NULL;
+	}
+	tnt_mem_free(s->data);
+}
+
+static ssize_t
+tnt_rpl_recv_cb(struct tnt_stream *s, char *buf, ssize_t size) {
+	struct tnt_stream_net *sn = TNT_SNET_CAST(s);
+	return tnt_io_recv(sn, buf, size);
+}
+
+static int
+tnt_rpl_request(struct tnt_stream *s, struct tnt_request *r)
+{
+	struct tnt_stream_rpl *sr = TNT_RPL_CAST(s);
+	struct tnt_stream_net *sn = TNT_SNET_CAST(sr->net);
+	/* fetching header */
+	if (tnt_io_recv(sn, (char*)&sr->hdr, sizeof(sr->hdr)) == -1)
+		return -1;
+	/* fetching row header */
+	if (tnt_io_recv(sn, (char*)&sr->row, sizeof(sr->row)) == -1)
+		return -1;
+	/* preparing pseudo iproto header */
+	struct tnt_header hdr_iproto;
+	hdr_iproto.type = sr->row.op;
+	hdr_iproto.len = sr->hdr.len - sizeof(struct tnt_log_row_v11);
+	hdr_iproto.reqid = 0;
+	/* deserializing operation */
+	if (tnt_request_from(r, (tnt_request_t)tnt_rpl_recv_cb,
+			     sr->net,
+			     &hdr_iproto) == -1)
+		return -1;
+	return 0;
+}
+
+/*
+ * tnt_rpl()
+ *
+ * create and initialize replication stream;
+ *
+ * s - stream pointer, maybe NULL
+ * 
+ * if stream pointer is NULL, then new stream will be created. 
+ *
+ * returns stream pointer, or NULL on error.
+*/
+struct tnt_stream *tnt_rpl(struct tnt_stream *s)
+{
+	int allocated = s == NULL;
+	s = tnt_stream_init(s);
+	if (s == NULL)
+		return NULL;
+	/* allocating stream data */
+	s->data = tnt_mem_alloc(sizeof(struct tnt_stream_rpl));
+	if (s->data == NULL)
+		goto error;
+	memset(s->data, 0, sizeof(struct tnt_stream_rpl));
+	/* initializing interfaces */
+	s->read = NULL;
+	s->read_request = tnt_rpl_request;
+	s->read_reply = NULL;
+	s->read_tuple = NULL;
+	s->write = NULL;
+	s->writev = NULL;
+	s->free = tnt_rpl_free;
+	/* initializing internal data */
+	struct tnt_stream_rpl *sr = TNT_RPL_CAST(s);
+	sr->net = NULL;
+	return s;
+error:
+	if (s->data) {
+		tnt_mem_free(s->data);
+		s->data = NULL;
+	}
+	if (allocated)
+		tnt_stream_free(s);
+	return NULL;
+}
+
+/*
+ * tnt_rpl_open()
+ *
+ * connect to a server and initialize handshake;
+ *
+ * s   - replication stream pointer
+ * lsn - start lsn 
+ *
+ * network stream must be properly initialized before
+ * this function called (see ttnt_rpl_net, tnt_set).
+ * 
+ * returns 0 on success, or -1 on error.
+*/
+int tnt_rpl_open(struct tnt_stream *s, uint64_t lsn)
+{
+	struct tnt_stream_rpl *sr = TNT_RPL_CAST(s);
+	/* intializing connection */
+	if (tnt_init(sr->net) == -1)
+		return -1;
+	if (tnt_connect(sr->net) == -1)
+		return -1;
+	/* sending initial lsn */
+	struct tnt_stream_net *sn = TNT_SNET_CAST(sr->net);
+	if (tnt_io_send_raw(sn, (char*)&lsn, sizeof(lsn), 1) == -1)
+		return -1;
+	/* reading and checking version */
+	uint32_t version = 0;
+	if (tnt_io_recv_raw(sn, (char*)&version, sizeof(version), 1) == -1)
+		return -1;
+	if (version != tnt_rpl_version)
+		return -1;
+	return 0;
+}
+
+/*
+ * tnt_rpl_close()
+ *
+ * close a connection; 
+ *
+ * s - replication stream pointer
+ * 
+ * returns 0 on success, or -1 on error.
+*/
+void tnt_rpl_close(struct tnt_stream *s) {
+	struct tnt_stream_rpl *sr = TNT_RPL_CAST(s);
+	if (sr->net)
+		tnt_close(s);
+}
+
+/*
+ * tnt_rpl_attach()
+ *
+ * attach network stream (tnt_stream_net object);
+ *
+ * s - replication stream pointer
+*/
+void tnt_rpl_attach(struct tnt_stream *s, struct tnt_stream *net) {
+	TNT_RPL_CAST(s)->net = net;
+}

data/ext/lwtarantool/vendor/tarantool-c/tntrpl/tnt_rpl.h

@@ -0,0 +1,47 @@
+#ifndef TNT_RPL_H_INCLUDED
+#define TNT_RPL_H_INCLUDED
+
+/*
+ * 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.
+ */
+
+struct tnt_stream_rpl {
+	struct tnt_log_header_v11 hdr;
+	struct tnt_log_row_v11 row;
+	struct tnt_stream *net;
+};
+
+#define TNT_RPL_CAST(S) ((struct tnt_stream_rpl*)(S)->data)
+
+struct tnt_stream *tnt_rpl(struct tnt_stream *s);
+void tnt_rpl_attach(struct tnt_stream *s, struct tnt_stream *net);
+
+int tnt_rpl_open(struct tnt_stream *s, uint64_t lsn);
+void tnt_rpl_close(struct tnt_stream *s);
+
+#endif /* TNT_XLOG_H_INCLUDED */

data/ext/lwtarantool/vendor/tarantool-c/tntrpl/tnt_snapshot.c

@@ -0,0 +1,163 @@
+
+/*
+ * 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 <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+
+#include <third_party/crc32.h>
+
+#include <tarantool.h>
+#include <tnt_log.h>
+#include <tnt_snapshot.h>
+
+static void tnt_snapshot_free(struct tnt_stream *s) {
+	struct tnt_stream_snapshot *ss = TNT_SSNAPSHOT_CAST(s);
+	tnt_log_close(&ss->log);
+	tnt_mem_free(s->data);
+	s->data = NULL;
+}
+
+static int
+tnt_snapshot_read_tuple(struct tnt_stream *s, struct tnt_tuple *t)
+{
+	struct tnt_stream_snapshot *ss = TNT_SSNAPSHOT_CAST(s);
+
+	struct tnt_log_row *row =
+		tnt_log_next_to(&ss->log, (union tnt_log_value*)t);
+
+	if (row == NULL && tnt_log_error(&ss->log) == TNT_LOG_EOK)
+		return 1;
+
+	return (row) ? 0: -1;
+}
+
+/*
+ * tnt_snapshot()
+ *
+ * create and initialize snapshot stream;
+ *
+ * s - stream pointer, maybe NULL
+ *
+ * if stream pointer is NULL, then new stream will be created.
+ *
+ * returns stream pointer, or NULL on error.
+*/
+struct tnt_stream *tnt_snapshot(struct tnt_stream *s)
+{
+	int allocated = s == NULL;
+	s = tnt_stream_init(s);
+	if (s == NULL)
+		return NULL;
+	/* allocating stream data */
+	s->data = tnt_mem_alloc(sizeof(struct tnt_stream_snapshot));
+	if (s->data == NULL) {
+		if (allocated)
+			tnt_stream_free(s);
+		return NULL;
+	}
+	memset(s->data, 0, sizeof(struct tnt_stream_snapshot));
+	/* initializing interfaces */
+	s->read = NULL;
+	s->read_request = NULL;
+	s->read_reply = NULL;
+	s->read_tuple = tnt_snapshot_read_tuple;
+	s->write = NULL;
+	s->writev = NULL;
+	s->free = tnt_snapshot_free;
+	/* initializing internal data */
+	return s;
+}
+
+/*
+ * tnt_snapshot_open()
+ *
+ * open snapshot file and associate it with stream;
+ *
+ * s - snapshot stream pointer
+ *
+ * returns 0 on success, or -1 on error.
+*/
+int tnt_snapshot_open(struct tnt_stream *s, char *file) {
+	struct tnt_stream_snapshot *ss = TNT_SSNAPSHOT_CAST(s);
+	return tnt_log_open(&ss->log, file, TNT_LOG_SNAPSHOT);
+}
+
+/*
+ * tnt_snapshot_close()
+ *
+ * close snapshot stream;
+ *
+ * s - snapshot stream pointer
+ *
+ * returns 0 on success, or -1 on error.
+*/
+void tnt_snapshot_close(struct tnt_stream *s) {
+	struct tnt_stream_snapshot *ss = TNT_SSNAPSHOT_CAST(s);
+	tnt_log_close(&ss->log);
+}
+
+/*
+ * tnt_snapshot_error()
+ *
+ * get stream error status;
+ *
+ * s - snapshot stream pointer
+*/
+enum tnt_log_error tnt_snapshot_error(struct tnt_stream *s) {
+	return TNT_SSNAPSHOT_CAST(s)->log.error;
+}
+
+/*
+ * tnt_snapshot_strerror()
+ *
+ * get stream error status description string;
+ *
+ * s - snapshot stream pointer
+*/
+char *tnt_snapshot_strerror(struct tnt_stream *s) {
+	return tnt_log_strerror(&TNT_SSNAPSHOT_CAST(s)->log);
+}
+
+/*
+ * tnt_snapshot_errno()
+ *
+ * get saved errno;
+ *
+ * s - snapshot stream pointer
+*/
+int tnt_snapshot_errno(struct tnt_stream *s) {
+	return TNT_SSNAPSHOT_CAST(s)->log.errno_;
+}

data/ext/lwtarantool/vendor/tarantool-c/tntrpl/tnt_snapshot.h

@@ -0,0 +1,50 @@
+#ifndef TNT_SNAPSHOT_H_INCLUDED
+#define TNT_SNAPSHOT_H_INCLUDED
+
+/*
+ * 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 <tarantool/tnt_log.h>
+
+struct tnt_stream_snapshot {
+	struct tnt_log log;
+};
+
+#define TNT_SSNAPSHOT_CAST(S) ((struct tnt_stream_snapshot*)(S)->data)
+
+struct tnt_stream *tnt_snapshot(struct tnt_stream *s);
+
+int tnt_snapshot_open(struct tnt_stream *s, char *file);
+void tnt_snapshot_close(struct tnt_stream *s);
+
+enum tnt_log_error tnt_snapshot_error(struct tnt_stream *s);
+char *tnt_snapshot_strerror(struct tnt_stream *s);
+int tnt_snapshot_errno(struct tnt_stream *s);
+
+#endif /* TNT_SNAPSHOT_H_INCLUDED */