fix(schema): avoid deadlock on reload_schema error

Ensure reload_schema always clears reload_in_progress flag
and broadcasts condition variable even if schema reload
fails or times out.

Previously, an early return on error left reload_in_progress
set to true, causing subsequent crud.schema() calls to wait
until timeout indefinitely.

Add integration test reproducing the issue and verifying that
schema reload can be retried successfully after a failure.

Fixes #479

Author: vakhov

crud/common/schema.lua

@@ -58,28 +58,38 @@ function schema.reload_schema(vshard_router)
     local replicasets = vshard_router:routeall()
     local vshard_router_name = vshard_router.name
 
+    if reload_schema_cond[vshard_router_name] == nil then
+        reload_schema_cond[vshard_router_name] = fiber.cond()
+    end
+
     if reload_in_progress[vshard_router_name] == true then
         if not reload_schema_cond[vshard_router_name]:wait(const.RELOAD_SCHEMA_TIMEOUT) then
             return nil, ReloadSchemaError:new('Waiting for schema to be reloaded is timed out')
         end
+        return true
+    end
+
+    reload_in_progress[vshard_router_name] = true
+
+    local ok, err
+    local p_ok, p_res1, p_res2 = pcall(call_reload_schema, replicasets)
+    if p_ok then
+        ok, err = p_res1, p_res2
     else
-        reload_in_progress[vshard_router_name] = true
-        if reload_schema_cond[vshard_router_name] == nil then
-            reload_schema_cond[vshard_router_name] = fiber.cond()
-        end
+        ok, err = nil, p_res1
+    end
 
-        local ok, err = call_reload_schema(replicasets)
-        if not ok then
-            return nil, err
-        end
+    reload_in_progress[vshard_router_name] = false
+    reload_schema_cond[vshard_router_name]:broadcast()
 
-        reload_schema_cond[vshard_router_name]:broadcast()
-        reload_in_progress[vshard_router_name] = false
+    if not ok then
+        return nil, err
     end
 
     return true
 end
 
+
 -- schema.wrap_func_reload calls func with specified arguments.
 -- func should return `res, err, need_reload`
 -- If function returned error and `need_reload` is true,

test/integration/schema_reload_deadlock_test.lua

@@ -0,0 +1,53 @@
+local t = require('luatest')
+local helpers = require('test.helper')
+
+local pgroup = t.group('schema_reload_deadlock', helpers.backend_matrix({
+    { engine = 'memtx' },
+}))
+
+pgroup.before_all(function(g)
+    helpers.start_default_cluster(g, 'srv_select')
+end)
+
+pgroup.after_all(function(g)
+    helpers.stop_cluster(g.cluster, g.params.backend)
+end)
+
+pgroup.before_each(function(g)
+    g._old_reload_schema_timeout = g.router:exec(function(new_timeout)
+        local const = require('crud.common.const')
+        local old = const.RELOAD_SCHEMA_TIMEOUT
+        const.RELOAD_SCHEMA_TIMEOUT = new_timeout
+        return old
+    end, { 0.2 })
+end)
+
+pgroup.after_each(function(g)
+    if g._old_reload_schema_timeout ~= nil then
+        g.router:exec(function(prev_timeout)
+            local const = require('crud.common.const')
+            const.RELOAD_SCHEMA_TIMEOUT = prev_timeout
+        end, { g._old_reload_schema_timeout })
+
+        g._old_reload_schema_timeout = nil
+    end
+end)
+
+pgroup.test_schema_reload_in_progress_is_cleared_after_error = function(g)
+    local _, err = g.router:call('crud.schema')
+    t.assert_equals(err, nil)
+
+    t.assert_is_not(g.cluster:server('s2-master'), nil)
+    g.cluster:server('s2-master'):stop()
+
+    local _, err1 = g.router:call('crud.schema')
+    t.assert_is_not(err1, nil)
+    t.assert_str_contains(err1.err, 'timed out')
+
+    g.cluster:server('s2-master'):start()
+
+    t.helpers.retrying({ timeout = 30, delay = 0.1 }, function()
+        local _, err2 = g.router:call('crud.schema')
+        t.assert_equals(err2, nil)
+    end)
+end