release lock in pool:put(conn)

The absence of this operation could lead to an infinite bloсking
when used with fiber as describerd in the case below.

A connection conn is acquired from a pool and we acquire a lock.
Then we start the first fiber with pool:put(conn)`, which try to
acquire lock and yield. Then the second fiber is started to
perform request with `conn:execute()` which try to acquire lock,
because the connection is still marked as `usable` and yield too.
Before this patch, it's appeared that the lock is never released.

Closes #34

Author: romanhabibov

mysql/init.lua

@@ -66,12 +66,10 @@ end
 local function conn_put(conn)
     local mysqlconn = conn.conn
     ffi.gc(conn.__gc_hook, nil)
-    if not conn.queue:get() then
-        conn.usable = false
-        return POOL_EMPTY_SLOT
-    end
+    local result = (conn.queue:get() and mysqlconn) or POOL_EMPTY_SLOT
     conn.usable = false
-    return mysqlconn
+    conn.queue:put(false)
+    return result
 end
 
 conn_mt = {
@@ -84,6 +82,12 @@ conn_mt = {
                 self.queue:put(false)
                 error('Connection is broken')
             end
+            -- Connection could become unusable, so that release
+            -- lock taken above and throw error.
+            if not self.usable then
+                self.queue:put(false)
+                error('Connection is not usable')
+            end
             local status, datas
             if select('#', ...) > 0 then
                 status, datas = self.conn:execute_prepared(sql, ...)

test/mysql.test.lua

@@ -516,8 +516,34 @@ local function test_underlying_conn_closed_during_gc(test)
     test:ok(ffi.C.fcntl(handle, F_GETFD) == -1, 'descriptor is closed')
 end
 
+--- gh-34: Check that fiber is not blocked in the following case.
+-- A connection conn is acquired from a pool and we acquire a
+-- lock. Then we start the first fiber with pool:put(conn)`, which
+-- try to acquire lock and yield. Then the second fiber is started
+-- to perform request with `conn:execute()` which try to acquire
+-- lock, because the connection is still marked as `usable` and
+-- yield too. It's appeared that the lock is never released. Now,
+-- it's fixed.
+local function test_block_fiber_inf(test, pool)
+    test:plan(1)
+    local conn = pool:get()
+    local fiber_blocked
+    local clock = require("clock")
+    local function test_fiber_block_request(conn)
+        fiber_blocked = fiber.self()
+        conn:execute('SELECT "a"')
+    end
+    conn.queue:get()
+    fiber.create(pool.put, pool, conn)
+    local start_time = clock.monotonic()
+    local timeout = 1
+    fiber.create(test_fiber_block_request, conn)
+    conn.queue:put(true)
+    test:ok(clock.monotonic() - start_time < timeout, 'fiber is not blocked')
+end
+
 local test = tap.test('mysql connector')
-test:plan(8)
+test:plan(9)
 
 test:test('connection old api', test_old_api, conn)
 local pool_conn = p:get()
@@ -529,6 +555,7 @@ test:test('connection pool', test_connection_pool, p)
 test:test('connection reset', test_connection_reset, p)
 test:test('test_underlying_conn_closed_during_gc',
           test_underlying_conn_closed_during_gc, p)
+test:test('test_block_fiber_inf', test_block_fiber_inf, p)
 p:close()
 
 os.exit(test:check() and 0 or 1)