lwtarantool 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3a10bfa0d8c43049eaff1705cb971ae461cca2bc
+  data.tar.gz: d823ef8761beeb1f8f44babb0162891549c8e2af
+SHA512:
+  metadata.gz: 69a06f61c2a266a33ec9a4f3bc40df1c12eeda7ee23caafa37d86bd3ffcdaac947aa55e65943ba9456ef6118738559e8e5a82c39339f30eac0181970933ae8b0
+  data.tar.gz: 08d0f5c944dbf08a519b95ef625e6389356f58eeef0497fca8067bbada91facfe05f185aad213c033002b4c2c07402da251a4230339e6b98123d2052cb82847d

data/README.md

@@ -0,0 +1,84 @@
+# LWTarantool - Ruby client for Tarantool 1.7+
+
+[![Build Status](https://semaphoreci.com/api/v1/0xbf/lwtarantool/branches/master/shields_badge.svg)](https://semaphoreci.com/0xbf/lwtarantool)
+[![Gem Version](https://badge.fury.io/rb/lwtarantool.svg)](https://badge.fury.io/rb/lwtarantool)
+
+## About
+
+A Ruby client for Tarantool 1.7+.
+
+It doesn't support all tarantool protocol features, the only function calls, but allow work with tarantool in async paradigm.
+
+Based on official [tarantool-c](https://github.com/tarantool/tarantool-c) connector.
+
+## Getting started
+
+### Install
+
+```
+$ gem install lwtarantool
+```
+
+### Connect
+
+```ruby
+require 'lwtarantool'
+tnt = LWTarantool.new(url: '127.0.0.1:3301')
+```
+
+### Pipelining
+
+```ruby
+reqs = []
+reqs << conn.call('box.slab.info', [])
+reqs << conn.call('box.runtime.info', [])
+
+reqs.each(&:wait)
+
+if reqs[0].result
+  puts "req0 result: #{reqs[0].result.inspect}"
+else
+  puts "req0 error: #{reqs[0].error}"
+end
+
+if reqs[1].result
+  puts "req1 result: #{reqs[1].result.inspect}"
+else
+  puts "req1 error: #{reqs[1].error}"
+end
+```
+
+### Async requests
+
+```ruby
+slab_req = conn.call('box.slab.info', [])
+runtime_req = conn.call('box.runtime.info', [])
+
+2.times do
+  req = conn.read
+  case req
+  when slab_req
+    if req.result
+      puts "slab info: #{req.result.inspect}"
+    else
+      puts "slab info error: #{req.error}"
+    end
+  when runtime_req
+    if req.result
+      puts "runtime info: #{req.result.inspect}"
+    else
+      puts "runtime info error: #{req.error}"
+    end
+  end
+end
+```
+
+## Error handling
+
+## Testing
+
+This library is tested against recent Ruby versions. Check [Semaphore CI](https://semaphoreci.com/0xbf/lwtarantool) for the exact versions supported.
+
+## Contributing
+
+Fork the project and send pull requests.

data/ext/lwtarantool/conn.c

@@ -0,0 +1,314 @@
+#include <ruby.h>
+#include <ruby/st.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <tarantool/tarantool.h>
+#include <tarantool/tnt_net.h>
+#include <tarantool/tnt_opt.h>
+
+#include "lwtarantool.h"
+
+
+static int
+lwt_conn_interrupt_request(uint64_t *id, VALUE req) {
+  struct tnt_reply *reply = tnt_reply_init(NULL);
+
+  char * error = "Request canceled due to connection close";
+
+  reply->code = -1;
+  reply->error = error;
+  reply->error_end = error + strlen(error);
+
+  lwt_request_add_reply(req, reply);
+
+  return ST_DELETE;
+}
+
+static int
+lwt_conn_mark_request(uint64_t *id, VALUE req) {
+  rb_gc_mark(req);
+  return ST_CONTINUE;
+}
+
+static void
+lwt_conn_mark(void *s) {
+  lwt_conn_t *conn = (lwt_conn_t *) s;
+  st_foreach(conn->requests, lwt_conn_mark_request, 0);
+}
+
+static void
+lwt_conn_dealloc(lwt_conn_t *conn) {
+  if (conn == NULL)
+    return;
+
+  if (conn->tnt != NULL) {
+    tnt_close(conn->tnt);
+    tnt_stream_free(conn->tnt);
+  }
+  if (conn->requests) {
+    st_clear(conn->requests);
+    st_free_table(conn->requests);
+  }
+}
+
+static VALUE
+lwt_conn_alloc( VALUE klass) {
+  lwt_conn_t * conn;
+  conn = ZALLOC(lwt_conn_t);
+
+  conn->tnt = tnt_net(NULL);
+  conn->requests = st_init_numtable();
+
+  return Data_Wrap_Struct( klass, lwt_conn_mark, lwt_conn_dealloc, conn);
+}
+
+static void
+lwt_conn_raise_error(lwt_conn_t *conn) {
+  switch(tnt_error(conn->tnt)) {
+    case TNT_EMEMORY:
+      rb_raise(rb_eNoMemError, tnt_strerror(conn->tnt));
+      break;
+    case TNT_ERESOLVE:
+      rb_raise(lwt_eResolvError, tnt_strerror(conn->tnt));
+      break;
+    case TNT_ETMOUT:
+      rb_raise(lwt_eTimeoutError, tnt_strerror(conn->tnt));
+      break;
+    case TNT_ELOGIN:
+      rb_raise(lwt_eLoginError, tnt_strerror(conn->tnt));
+      break;
+    case TNT_ESYSTEM:
+      rb_raise(lwt_eSystemError, tnt_strerror(conn->tnt));
+      break;
+    case TNT_EFAIL:
+    case TNT_EBIG:
+    default:
+      rb_raise(lwt_eUnknownError, tnt_strerror(conn->tnt));
+      break;
+  }
+}
+
+static VALUE
+lwt_conn_connect(VALUE self) {
+  lwt_conn_t * conn;
+  Data_Get_Struct(self, lwt_conn_t, conn);
+
+  if (tnt_connect(conn->tnt) < 0)
+    lwt_conn_raise_error(conn);
+
+  return Qtrue;
+}
+
+static VALUE
+lwt_conn_disconnect(VALUE self) {
+  lwt_conn_t * conn;
+  Data_Get_Struct(self, lwt_conn_t, conn);
+
+  tnt_close(conn->tnt);
+  st_foreach(conn->requests, lwt_conn_interrupt_request, 0);
+
+  return Qtrue;
+}
+
+/**
+ * Document-class: LWTarantool::Connection
+ *
+ * Create new connection to Tarantool.
+ *
+ * @param [Hash] args the options to establish connection
+ * @option args [String] :url The tarantool address
+ *
+ * @example
+ *   LWTarantool::Connection.new(url: 'tcp://127.0.0.1:3301')
+ *
+ * @return [LWTarantool::Connection] a new connection instance.
+ *
+ * @raise [LWTarantool::ResolvError] destination host can't be resolved
+ * @raise [LWTarantool::TimeoutError] connect timeout reached
+ * @raise [LWTarantool::LoginError] incorrect login or password
+ * @raise [LWTarantool::SystemError] connection failed
+ * @raise [LWTarantool::UnknownError] unknown error
+ */
+static VALUE
+lwt_conn_initialize(VALUE self, VALUE args) {
+  lwt_conn_t * conn;
+  Data_Get_Struct(self, lwt_conn_t, conn);
+
+  VALUE val;
+
+  val = rb_mutex_new();
+  rb_iv_set(self, "@mutex", val);
+
+  if (TYPE(args) != T_HASH)
+    rb_raise(rb_eArgError, "args must be a Hash");
+
+  val = rb_hash_aref(args, ID2SYM(rb_intern( "url")));
+  if (TYPE(val) != T_STRING)
+    rb_raise(rb_eArgError, "url must be a String");
+
+  int url_len = RSTRING_LEN(val);
+  char url[url_len+1];
+  url[url_len] = '\0';
+  strncpy(url, RSTRING_PTR(val), url_len);
+
+  tnt_set(conn->tnt, TNT_OPT_URI, url);
+
+  lwt_conn_connect(self);
+
+  return Qnil;
+}
+
+static VALUE
+lwt_conn_call(VALUE self, VALUE func, VALUE args) {
+  lwt_conn_t * conn;
+  Data_Get_Struct(self, lwt_conn_t, conn);
+
+  if (TYPE(func) != T_STRING)
+    rb_raise(rb_eArgError, "function name must be a String");
+
+  if (TYPE(args) != T_STRING)
+    rb_raise(rb_eArgError, "args must be a string with msgpack array");
+
+  int func_len = RSTRING_LEN(func);
+  char func_name[func_len+1];
+  func_name[func_len] = '\0';
+  strncpy(func_name, RSTRING_PTR(func), func_len);
+
+  uint64_t reqid = conn->tnt->reqid;
+  VALUE req;
+
+  struct tnt_stream * data;
+  data = tnt_object(NULL);
+  if (data == NULL)
+    rb_raise(rb_eNoMemError, "Can't create tnt_object");
+
+  if (data->write(data, RSTRING_PTR(args), RSTRING_LEN(args)) < 0) {
+    tnt_stream_free(data);
+    rb_raise(rb_eNoMemError, "Can't store args");
+  }
+
+  if (tnt_call(conn->tnt, func_name, func_len, data) < 0) {
+    tnt_stream_free(data);
+    lwt_conn_raise_error(conn);
+  }
+
+  if (tnt_flush(conn->tnt) < 0) {
+    tnt_stream_free(data);
+    lwt_conn_raise_error(conn);
+  }
+
+  tnt_stream_free(data);
+
+  req = lwt_request_create(self, reqid);
+  st_insert( conn->requests, reqid, req);
+
+  return req;
+}
+
+static VALUE
+lwt_conn_read(VALUE self) {
+  lwt_conn_t * conn;
+  Data_Get_Struct(self, lwt_conn_t, conn);
+
+  VALUE req;
+  struct tnt_reply *reply = tnt_reply_init(NULL);
+
+  int rc = conn->tnt->read_reply(conn->tnt, reply);
+  //printf("sync: %d, code: %d, err: %d, errno: %d, strerr: %s\n", rc, reply->sync, reply->code, tnt_error(conn->tnt), tnt_errno(conn->tnt), tnt_strerror(conn->tnt));
+
+  if (rc == 1)
+    return Qnil;
+
+  if (rc == -1)
+    lwt_conn_raise_error(conn);
+
+  if (rc != 0)
+    rb_raise( lwt_eUnknownError, "read_reply() return code %d", rc);
+
+  if (st_delete(conn->requests, &reply->sync, &req) != 1)
+    rb_raise(lwt_eSyncError, "Bad sync id %lu in tarantool reply", reply->sync);
+
+  lwt_request_add_reply( req, reply);
+
+  return req;
+}
+
+/**
+ * Document-class: LWTarantool::Connection
+ *
+ * Check if connection established.
+ *
+ * @example
+ *   conn.connected?
+ *
+ * @return [Boolean]
+ */
+static VALUE
+lwt_conn_is_connected(VALUE self) {
+  lwt_conn_t * conn;
+  Data_Get_Struct(self, lwt_conn_t, conn);
+
+  struct tnt_stream_net *sn = TNT_SNET_CAST(conn->tnt);
+
+  if (sn->connected)
+    return Qtrue;
+  else
+    return Qfalse;
+}
+
+static VALUE
+lwt_conn_error(VALUE self) {
+  lwt_conn_t * conn;
+  Data_Get_Struct(self, lwt_conn_t, conn);
+
+  return rb_uint2inum(tnt_error(conn->tnt));
+}
+
+static VALUE
+lwt_conn_errno(VALUE self) {
+  lwt_conn_t * conn;
+  Data_Get_Struct(self, lwt_conn_t, conn);
+
+  return rb_uint2inum(tnt_errno(conn->tnt));
+}
+
+static VALUE
+lwt_conn_strerror(VALUE self) {
+  lwt_conn_t * conn;
+  Data_Get_Struct(self, lwt_conn_t, conn);
+
+  return rb_str_new_cstr(tnt_strerror(conn->tnt));
+}
+
+void init_conn() {
+  /*
+   * Document-class: LWTarantool::Connection
+   *
+   * Class for work with Tarantool connections
+   */
+  VALUE cClass = rb_define_class_under( lwt_Class, "Connection", rb_cObject);
+
+  rb_const_set( lwt_Class, rb_intern("TNT_EFAIL"), rb_uint2inum(TNT_EFAIL));
+  rb_const_set( lwt_Class, rb_intern("TNT_EMEMORY"), rb_uint2inum(TNT_EMEMORY));
+  rb_const_set( lwt_Class, rb_intern("TNT_ESYSTEM"), rb_uint2inum(TNT_ESYSTEM));
+  rb_const_set( lwt_Class, rb_intern("TNT_EBIG"), rb_uint2inum(TNT_EBIG));
+  rb_const_set( lwt_Class, rb_intern("TNT_ESIZE"), rb_uint2inum(TNT_ESIZE));
+  rb_const_set( lwt_Class, rb_intern("TNT_ERESOLVE"), rb_uint2inum(TNT_ERESOLVE));
+  rb_const_set( lwt_Class, rb_intern("TNT_ETMOUT"), rb_uint2inum(TNT_ETMOUT));
+  rb_const_set( lwt_Class, rb_intern("TNT_EBADVAL"), rb_uint2inum(TNT_EBADVAL));
+  rb_const_set( lwt_Class, rb_intern("TNT_ELOGIN"), rb_uint2inum(TNT_ELOGIN));
+
+  rb_define_alloc_func(cClass, lwt_conn_alloc);
+  rb_define_method(cClass, "initialize", lwt_conn_initialize, 1);
+  rb_define_private_method(cClass, "_connect", lwt_conn_connect, 0);
+  rb_define_private_method(cClass, "_disconnect", lwt_conn_disconnect, 0);
+  rb_define_private_method(cClass, "_error", lwt_conn_error, 0);
+  rb_define_private_method(cClass, "_errno", lwt_conn_errno, 0);
+  rb_define_private_method(cClass, "_strerror", lwt_conn_strerror, 0);
+  rb_define_private_method(cClass, "_call", lwt_conn_call, 2);
+  rb_define_private_method(cClass, "_read", lwt_conn_read, 0);
+
+  rb_define_method(cClass, "connected?", lwt_conn_is_connected, 0);
+}

data/ext/lwtarantool/depend

@@ -0,0 +1,23 @@
+$(DLLIB): tarantool-c/libtarantool.a msgpuck/libmsgpuck.a
+
+$(OBJS): $(HDRS) $(ruby_headers)
+
+msgpuck/libmsgpuck.a: Makefile
+	mkdir -p msgpuck
+	cd msgpuck && cmake ../$(srcdir)/vendor/msgpuck
+	make -C msgpuck msgpuck
+
+tarantool-c/libtarantool.a: Makefile
+	mkdir -p tarantool-c
+	cd tarantool-c && cmake ../$(srcdir)/vendor/tarantool-c -DMSGPUCK_INCLUDE_DIR=../$(srcdir)/vendor/msgpuck -DMSGPUCK_LIBRARY=../$(srcdir)/vendor/msgpuck
+	make -C tarantool-c tnt
+
+.PHONY: clean-msgpuck clean-tarantool-c
+
+clean: clean-msgpuck clean-tarantool-c
+
+clean-msgpuck:
+	-rm -rf msgpuck
+
+clean-tarantool-c:
+	-rm -rf tarantool-c

data/ext/lwtarantool/errors.c

@@ -0,0 +1,24 @@
+#include <ruby.h>
+#include "lwtarantool.h"
+
+VALUE lwt_eError = NULL;
+VALUE lwt_eLoginError = NULL;
+VALUE lwt_eResolvError = NULL;
+VALUE lwt_eSyncError = NULL;
+VALUE lwt_eSystemError = NULL;
+VALUE lwt_eTimeoutError = NULL;
+VALUE lwt_eUnknownError = NULL;
+
+void init_errors() {
+  lwt_eError = rb_define_class_under( lwt_Class, "Error", rb_eStandardError);
+  lwt_eLoginError = rb_define_class_under( lwt_Class, "LoginError", lwt_eError);
+  lwt_eSyncError = rb_define_class_under( lwt_Class, "SyncError", lwt_eError);
+  lwt_eSystemError = rb_define_class_under( lwt_Class, "SystemError", lwt_eError);
+  lwt_eResolvError = rb_define_class_under( lwt_Class, "ResolvError", lwt_eError);
+  lwt_eTimeoutError = rb_define_class_under( lwt_Class, "TimeoutError", lwt_eError);
+  lwt_eUnknownError = rb_define_class_under( lwt_Class, "UnknownError", lwt_eError);
+
+  //lwt_eLoginError = rb_define_class_under( lwt_Class, "LoginError", lwt_eError);
+  //lwt_eLoginError = rb_define_class_under( lwt_Class, "LoginError", lwt_eError);
+  //lwt_eLoginError = rb_define_class_under( lwt_Class, "LoginError", lwt_eError);
+}

data/ext/lwtarantool/extconf.rb

@@ -0,0 +1,8 @@
+require 'mkmf'
+
+$INCFLAGS << ' -I$(srcdir)/vendor/tarantool-c/include'
+$LIBPATH << 'msgpuck/'
+$LIBPATH << 'tarantool-c/tnt/'
+$LOCAL_LIBS = '-ltarantool -lmsgpuck'
+
+create_makefile 'lwtarantool/lwtarantool'

data/ext/lwtarantool/lwtarantool.c

@@ -0,0 +1,12 @@
+#include <ruby.h>
+#include "lwtarantool.h"
+
+VALUE lwt_Class;
+
+void Init_lwtarantool() {
+  lwt_Class = rb_define_module( "LWTarantool");
+
+  init_errors();
+  init_conn();
+  init_request();
+}

data/ext/lwtarantool/lwtarantool.h

@@ -0,0 +1,38 @@
+#include <ruby.h>
+#include <tarantool/tnt_reply.h>
+#include <tarantool/tnt_stream.h>
+
+#ifndef ZALLOC
+#  define ZALLOC_N(type,n) ((type*)xcalloc((n),sizeof(type)))
+#  define ZALLOC(type) (ZALLOC_N(type,1))
+#endif
+
+extern VALUE lwt_Class;
+
+extern VALUE lwt_eError;
+extern VALUE lwt_eLoginError;
+extern VALUE lwt_eResolvError;
+extern VALUE lwt_eSyncError;
+extern VALUE lwt_eSystemError;
+extern VALUE lwt_eTimeoutError;
+extern VALUE lwt_eUnknownError;
+
+
+typedef struct {
+    VALUE mutex;
+    struct tnt_stream *tnt;
+    st_table *requests;
+} lwt_conn_t;
+
+typedef struct {
+    VALUE conn;
+    uint64_t id;
+    struct tnt_reply *reply;
+} lwt_request_t;
+
+VALUE lwt_request_create( VALUE conn, uint64_t id);
+void lwt_request_add_reply( VALUE self, struct tnt_reply *reply);
+
+void init_conn();
+void init_request();
+void init_errors();

data/ext/lwtarantool/request.c

@@ -0,0 +1,124 @@
+#include <ruby.h>
+#include "lwtarantool.h"
+
+static VALUE rClass;
+
+VALUE
+lwt_request_create( VALUE conn, uint64_t id) {
+  VALUE self;
+  lwt_request_t * req;
+
+  req = ZALLOC(lwt_request_t);
+  req->id = id;
+
+  self = Data_Wrap_Struct( rClass, NULL, NULL, req);
+  rb_iv_set(self, "@conn", conn);
+
+  //printf("Create request %p, reply: %p\n", req, req->reply);
+
+  return self;
+}
+
+void
+lwt_request_add_reply( VALUE self, struct tnt_reply *reply) {
+  lwt_request_t * req;
+  Data_Get_Struct(self, lwt_request_t, req);
+
+  //printf("Add reply %p to request %p\n", reply, req);
+
+  req->reply = reply;
+}
+
+/*
+ * Document-class: LWTarantool::Request
+ *
+ * Request id
+ *
+ * @return [Integer] id
+ */
+static VALUE
+lwt_request_id( VALUE self) {
+  lwt_request_t * req;
+  Data_Get_Struct(self, lwt_request_t, req);
+
+  return rb_uint2inum(req->id);
+}
+
+/*
+ * Document-class: LWTarantool::Request
+ *
+ * Check if request already processed.
+ */
+static VALUE
+lwt_request_is_ready( VALUE self) {
+  lwt_request_t * req;
+  Data_Get_Struct(self, lwt_request_t, req);
+
+  if (req->reply == NULL) 
+    return Qfalse;
+  else
+    return Qtrue;
+}
+
+/*
+static VALUE
+lwt_request_code( VALUE self) {
+  lwt_request_t * req;
+  Data_Get_Struct(self, lwt_request_t, req);
+
+  if (req->reply == NULL) 
+    return Qnil;
+
+  return rb_uint2inum(req->reply->code);
+}
+*/
+
+static VALUE
+lwt_request_error( VALUE self) {
+  lwt_request_t * req;
+  Data_Get_Struct(self, lwt_request_t, req);
+
+  if (req->reply == NULL)
+    return Qnil;
+
+  if (req->reply->code == 0)
+    return Qnil;
+
+  if (req->reply->error == NULL)
+    return Qnil;
+
+  const char *data = req->reply->error;
+  size_t data_len = req->reply->error_end - data;
+  return rb_str_new(data, data_len);
+}
+
+static VALUE
+lwt_request_result( VALUE self) {
+  lwt_request_t * req;
+  Data_Get_Struct(self, lwt_request_t, req);
+
+  if (req->reply == NULL)
+    return Qnil;
+
+  if (req->reply->code != 0)
+    return Qnil;
+
+  const char *data = req->reply->data;
+  size_t data_len = req->reply->data_end - data;
+  return rb_str_new(data, data_len);
+}
+
+void init_request() {
+  /*
+   * Document-class: LWTarantool::Request
+   *
+   * Class for work with Tarantool requests
+   */
+  rClass = rb_define_class_under( lwt_Class, "Request", rb_cObject);
+
+  rb_define_method(rClass, "id", lwt_request_id, 0);
+  rb_define_method(rClass, "ready?", lwt_request_is_ready, 0);
+  //rb_define_method(rClass, "code", lwt_request_code, 0);
+  rb_define_private_method(rClass, "_error", lwt_request_error, 0);
+  rb_define_private_method(rClass, "_result", lwt_request_result, 0);
+}