return sock, err
end
+Thread = luci.util.class()
+
+function Thread.__init__(self, socket, func)
+ self.socket = socket
+ self.routine = coroutine.create(func)
+ self.stamp = os.time()
+ self.waiting = false
+end
+
+function Thread.touched(self)
+ return self.stamp
+end
+
+function Thread.iswaiting(self)
+ return self.waiting
+end
+
+function Thread.receive(self, ...)
+ local chunk, err, part
+ self.waiting = true
+
+ repeat
+ coroutine.yield()
+ chunk, err, part = self.socket:receive(...)
+ until err ~= "timeout"
+
+ self.waiting = false
+ return chunk, err, part
+end
+
+function Thread.resume(self, ...)
+ return coroutine.resume(self.routine, self, ...)
+end
+
+function Thread.isdead(self)
+ return coroutine.status(self.routine) == "dead"
+end
+
+function Thread.touch(self)
+ self.stamp = os.time()
+end
Daemon = luci.util.class()
-function Daemon.__init__(self, threadlimit, timeout)
+function Daemon.__init__(self, threadlimit, waittime, timeout)
self.reading = {}
- self.running = {}
+ self.threads = {}
self.handler = {}
+ self.waiting = {}
+ self.threadc = 0
+
+ setmetatable(self.waiting, {__mode = "v"})
+
self.debug = false
self.threadlimit = threadlimit
- self.timeout = timeout or 0.1
+ self.waittime = waittime or 0.1
+ self.timeout = timeout or 90
+end
+
+function Daemon.remove_dead(self, thread)
+ if self.debug then
+ self:dprint("Completed " .. tostring(thread))
+ end
+ thread.socket:close()
+ self.threadc = self.threadc - 1
+ self.threads[thread.socket] = nil
+end
+
+function Daemon.kill_timedout(self)
+ local now = os.time()
+
+ for sock, thread in pairs(self.threads) do
+ if os.difftime(now, thread:touched()) > self.timeout then
+ self.threads[sock] = nil
+ self.threadc = self.threadc - 1
+ sock:close()
+ end
+ end
end
function Daemon.dprint(self, msg)
function Daemon.step(self)
local input, output, err = socket.select( self.reading, nil, 0 )
-
- if err == "timeout" and #self.running == 0 then
- socket.sleep(self.timeout)
- end
+ local working = false
-- accept new connections
for i, connection in ipairs(input) do
if sock then
-- check capacity
- if not self.threadlimit or #self.running < self.threadlimit then
+ if not self.threadlimit or self.threadc < self.threadlimit then
if self.debug then
self:dprint("Accepted incoming connection from " .. sock:getpeername())
end
-
- table.insert( self.running, {
- coroutine.create( self.handler[connection].clhandler ),
- sock
- } )
+
+ local t = Thread(sock, self.handler[connection].clhandler)
+ self.threads[sock] = t
+ self.threadc = self.threadc + 1
if self.debug then
- self:dprint("Created " .. tostring(self.running[#self.running][1]))
+ self:dprint("Created " .. tostring(t))
end
-- reject client
else
+ self:kill_timedout()
+
if self.debug then
self:dprint("Rejected incoming connection from " .. sock:getpeername())
end
end
-- create client handler
- for i, client in ipairs( self.running ) do
-
- -- reap dead clients
- if coroutine.status( client[1] ) == "dead" then
+ for sock, thread in pairs( self.threads ) do
+ -- resume working threads
+ if not thread:iswaiting() then
if self.debug then
- self:dprint("Completed " .. tostring(client[1]))
- end
- table.remove( self.running, i )
- else
- if self.debug then
- self:dprint("Resuming " .. tostring(client[1]))
+ self:dprint("Resuming " .. tostring(thread))
end
- local stat, err = coroutine.resume( client[1], client[2] )
+ local stat, err = thread:resume()
+ if stat and not thread:isdead() then
+ thread:touch()
+ if not thread:iswaiting() then
+ working = true
+ else
+ table.insert(self.waiting, sock)
+ end
+ else
+ self:remove_dead(thread)
+ end
if self.debug then
- self:dprint(tostring(client[1]) .. " returned")
+ self:dprint(tostring(thread) .. " returned")
+ if not stat then
+ self:dprint("Error in " .. tostring(thread) .. " " .. err)
+ end
end
-
- if not stat and self.debug then
- self:dprint("Error in " .. tostring(client[1]) .. " " .. err)
+ end
+ end
+
+ -- check for data on waiting threads
+ input, output, err = socket.select( self.waiting, nil, 0 )
+
+ for i, sock in ipairs(input) do
+ local thread = self.threads[sock]
+ thread:resume()
+ if thread:isdead() then
+ self:remove_dead(thread)
+ else
+ thread:touch()
+
+ if not thread:iswaiting() then
+ for i, s in ipairs(self.waiting) do
+ if s == sock then
+ table.remove(self.waiting, i)
+ break
+ end
+ end
+ if not working then
+ working = true
+ end
end
end
end
+
+ if err == "timeout" and not working then
+ self:kill_timedout()
+ socket.sleep(self.waittime)
+ end
end