wsclient.lua

package.loaded['websocket.bit'] = require'bit.numberlua'.bit

local sync = require'websocket.sync'

local Resumer = {}
function Resumer.new(callback, thread)
    return setmetatable({thread = thread, req = nil, data = '', callback = callback}, {__index = Resumer})
end

function Resumer:resume(...)
    return select(2, coroutine.resume(self.thread, ...))
end

function Resumer:request(pattern)
    self.req = pattern
end

function Resumer:on_data(data)
    self.data = self.data .. data
    if self.req then
        local vals
        local ret, rest
        if self.req == '*l' then
            ret, rest = self.data:match('^(.-)\n(.+)$')
            if not ret then
                ret, rest = self.data, ''
            end

            if ret and coroutine.status(self.thread) ~= 'dead' then
                self.req = nil
                self.data = rest
                vals = {self:resume(ret)}
            end
        elseif type(self.req) == 'number' and coroutine.status(self.thread) ~= 'dead' then
            if #self.data >= self.req then
                ret, rest = self.data:sub(1, self.req), self.data:sub(self.req + 1)
                self.req = nil
                self.data = rest
                vals = {self:resume(ret)}
            end
        end

        if vals and coroutine.status(self.thread) == 'dead' and self.callback then
            self.callback(unpack(vals))
        end
    end
end

local new = function(connect_callback, send_callback, receive_callback, close_callback)
    local self = {}

    self.sock_connect = function(self, host, port)
        self.sock = net.createConnection(net.TCP, 0)
        self.sock:on("receive", function(sock, msg)
            if self.resumer then
                self.resumer:on_data(msg)
            end
        end)

        self.sock:connect(port, host)
    end

    self.sock_send = function(self, data)
        return self.sock:send(data, send_callback)
    end

    self.sock_receive = function(self, pattern, prefix)
        if self.resumer then
            self.resumer:request(pattern)
            return coroutine.yield()
        end
    end

    self.sock_close = function(self)
        self.sock:close()
    end

    self = sync.extend(self)

    self.resumer = Resumer.new(
        function(...)
            connect_callback(...)

            local callback = function(...)
                receive_callback(...)
                self.resumer = Resumer.new(callback, coroutine.create(self.receive))
                self.resumer:resume(self)
            end
            self.resumer = Resumer.new(callback, coroutine.create(self.receive))
            self.resumer:resume(self)
        end,

        coroutine.create(self.connect)
    )
    self.connect = function(...)
        self.resumer:resume(...)
    end

    local close_resumer = Resumer.new(close_callback, coroutine.create(self.close))
    self.close = function(...)
        self.resumer = close_resumer
        self.resumer:resume(...)
    end

    return self
end

return new