Return redis connections to the worker pool

app/controllers/1/syncs_controller.lua

@@ -295,4 +295,36 @@ function SyncsController:healthcheck()
     return 200, { state = 'OK' }
 end
 
+-- gin dispatches straight to the action and turns raise_error into a response
+-- with pcall, so an action has no return point every path passes through. The
+-- connection goes back to the pool here, inside the content phase: nginx
+-- finalizes cosockets before log_by_lua runs, where set_keepalive fails with
+-- "closed".
+local function releasing(action)
+    return function(self, ...)
+        local ok, status, body, headers = pcall(action, self, ...)
+        if self.redis then
+            Redis.release(self.redis)
+            self.redis = nil
+        end
+        if not ok then
+            error(status, 0)
+        end
+        return status, body, headers
+    end
+end
+
+for _, action in ipairs({
+    "auth_user",
+    "create_user",
+    "create_user_disabled",
+    "delete_user",
+    "update_password",
+    "get_progress",
+    "update_progress",
+    "healthcheck"
+}) do
+    SyncsController[action] = releasing(SyncsController[action])
+end
+
 return SyncsController

db/redis.lua

@@ -29,16 +29,43 @@ local Redis = {
     options = {},
 }
 
+-- How long an idle connection is held. config/redis.conf sets `timeout 0`, so
+-- the server never closes one first.
+local keepalive_timeout = 60000
+
+-- One pool per database. A reused connection is the same socket, so it is
+-- already on the database it selected, and connections that selected another
+-- are in another pool. port is formatted, not concatenated: a unix socket
+-- configuration leaves it unset.
+local function pool_name(option)
+    return string.format("%s:%s/%s", option.host, tostring(option.port), option.database)
+end
+
 function Redis:new()
     local redis = require("resty.redis")
     local option = DbSettings[Gin.env]
     local red = redis:new()
     red:set_timeout(1000) -- 1 sec
-    local ok, err = red:connect(option.host, option.port)
+    local ok, err = red:connect(option.host, option.port, {
+        pool = pool_name(option),
+        pool_size = option.pool
+    })
     if ok then
-        red:select(option.database)
+        -- Only a new socket needs it; see pool_name above.
+        if red:get_reused_times() == 0 then
+            red:select(option.database)
+        end
         return red
     end
 end
 
+-- Returns the connection to the pool. set_keepalive refuses a socket with an
+-- unread reply or a read or write error, and close is the fallback.
+function Redis.release(red)
+    local option = DbSettings[Gin.env]
+    if not red:set_keepalive(keepalive_timeout, option.pool) then
+        red:close()
+    end
+end
+
 return Redis