prosody-hg: net/server_select.lua comparison

comparison net/server_select.lua @ 2131:72411e239221

net.server_select: Bring up to date to new common connection API

author	Matthew Wild <mwild1@gmail.com>
date	Sun, 22 Nov 2009 04:45:13 +0000
parents	0dc5eb9dbb62
children	459c1d1cae95

comparison

equal deleted inserted replaced

-:828e161cdfc7
+:72411e239221
 maxconnections = maxconnections or _maxclientsperserver
 local connections = 0
-local dispatch, disconnect = listeners.incoming or listeners.listener, listeners.disconnect
+local dispatch, disconnect = listeners.onincoming, listeners.ondisconnect
 local err
 local ssl = false
 end
 handler.close = function( )
 for _, handler in pairs( _socketlist ) do
 if handler.serverport == serverport then
 handler.disconnect( handler, "server closed" )
-handler.close( true )
+handler:close( true )
 end
 end
 socket:close( )
 _sendlistlen = removesocket( _sendlist, socket, _sendlistlen )
 _readlistlen = removesocket( _readlist, socket, _readlistlen )
 --// private closures of the object //--
 local ssl
-local dispatch = listeners.incoming or listeners.listener
+local dispatch = listeners.onincoming
 local status = listeners.status
-local disconnect = listeners.disconnect
+local disconnect = listeners.ondisconnect
 local bufferqueue = { }    -- buffer array
 local bufferqueuelen = 0    -- end of buffer array
 local toclose
 return dispatch
 end
 handler.disconnect = function( )
 return disconnect
 end
-handler.setlistener = function( listeners )
+handler.setlistener = function( self, listeners )
-dispatch = listeners.incoming
+dispatch = listeners.onincoming
-disconnect = listeners.disconnect
+disconnect = listeners.ondisconnect
 end
 handler.getstats = function( )
 return readtraffic, sendtraffic
 end
 handler.ssl = function( )
 return serverport
 end
 handler.clientport = function( )
 return clientport
 end
-local write = function( data )
+local write = function( self, data )
 bufferlen = bufferlen + string_len( data )
 if bufferlen > maxsendlen then
 _closelist[ handler ] = "send buffer exceeded"   -- cannot close the client at the moment, have to wait to the end of the cycle
 handler.write = idfalse    -- dont write anymore
 return false
 	_writetimes[ handler ] = _writetimes[ handler ] or _currenttime
 end
 return true
 end
 handler.write = write
-handler.bufferqueue = function( )
+handler.bufferqueue = function( self )
 return bufferqueue
 end
-handler.socket = function( )
+handler.socket = function( self )
 return socket
 end
-handler.pattern = function( new )
+handler.pattern = function( self, new )
 pattern = new or pattern
 return pattern
 end
-handler.setsend = function ( newsend )
+handler.setsend = function ( self, newsend )
 send = newsend or send
 return send
 end
-handler.bufferlen = function( readlen, sendlen )
+handler.bufferlen = function( self, readlen, sendlen )
 maxsendlen = sendlen or maxsendlen
 maxreadlen = readlen or maxreadlen
 return maxreadlen, maxsendlen
 end
-handler.lock = function( switch )
+handler.lock = function( self, switch )
 if switch == true then
 handler.write = idfalse
 local tmp = _sendlistlen
 _sendlistlen = removesocket( _sendlist, socket, _sendlistlen )
 _writetimes[ handler ] = nil
 end
 if succ then    -- sending succesful
 bufferqueuelen = 0
 bufferlen = 0
 _sendlistlen = removesocket( _sendlist, socket, _sendlistlen )    -- delete socket from writelist
-_ = needtls and handler.starttls(true)
+_ = needtls and handler:starttls(true)
 _writetimes[ handler ] = nil
 	    _ = toclose and handler.close( )
 return true
 elseif byte and ( err == "timeout" or err == "wantwrite" ) then    -- want write
 buffer = string_sub( buffer, byte + 1, bufferlen )    -- new buffer
 end
 end
 -- Set the sslctx
 local handshake;
-function handler.set_sslctx(new_sslctx)
+function handler.set_sslctx(self, new_sslctx)
 ssl = true
 sslctx = new_sslctx;
 local wrote
 local read
 handshake = coroutine_wrap( function( client )    -- create handshake coroutine
 --coroutine_yield( handler, nil, err )    -- handshake not finished
 coroutine_yield( )
 end
 end
 disconnect( handler, "ssl handshake failed" )
-_ = handler and handler.close( true )    -- forced disconnect
+_ = handler and handler:close( true )    -- forced disconnect
 return false    -- handshake failed
 end
 )
 end
 if sslctx then    -- ssl?
-	handler.set_sslctx(sslctx);
+	handler:set_sslctx(sslctx);
 if startssl then    -- ssl now?
 --out_put("server.lua: ", "starting ssl handshake")
 	    local err
 socket, err = ssl_wrap( socket, sslctx )    -- wrap socket
 if err then
 return nil, nil, "ssl handshake failed";
 end
 else
 -- We're not automatically doing SSL, so we're not secure (yet)
 ssl = false
-handler.starttls = function( now )
+handler.starttls = function( self, now )
 if not now then
 --out_put "server.lua: we need to do tls, but delaying until later"
 needtls = true
 return
 end
 removeserver = function( port )
 local handler = _server[ port ]
 if not handler then
 return nil, "no server found on port '" .. tostring( port ) .. "'"
 end
-handler.close( )
+handler:close( )
 _server[ port ] = nil
 return true
 end
 closeall = function( )
 for _, handler in pairs( _socketlist ) do
-handler.close( )
+handler:close( )
 _socketlist[ _ ] = nil
 end
 _readlistlen = 0
 _sendlistlen = 0
 _timerlistlen = 0
 out_put "server.lua: found no handler and closed socket (readlist)"    -- this can happen
 end
 end
 for handler, err in pairs( _closelist ) do
 handler.disconnect( )( handler, err )
-handler.close( true )    -- forced disconnect
+handler:close( true )    -- forced disconnect
 end
 clean( _closelist )
 _currenttime = os_time( )
 if os_difftime( _currenttime - _timer ) >= 1 then
 for i = 1, _timerlistlen do
 _starttime = _currenttime
 for handler, timestamp in pairs( _writetimes ) do
 if os_difftime( _currenttime - timestamp ) > _sendtimeout then
 --_writetimes[ handler ] = nil
 handler.disconnect( )( handler, "send timeout" )
-handler.close( true )    -- forced disconnect
+handler:close( true )    -- forced disconnect
 end
 end
 for handler, timestamp in pairs( _readtimes ) do
 if os_difftime( _currenttime - timestamp ) > _readtimeout then
 --_readtimes[ handler ] = nil
 handler.disconnect( )( handler, "read timeout" )
-handler.close( )    -- forced disconnect?
+handler:close( )    -- forced disconnect?
 end
 end
 end
 end
 )

Mercurial > prosody-hg

comparison net/server_select.lua @ 2131:72411e239221