ChatServ/server.py at master · spito/ChatServ · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
#!/usr/bin/env python

import asyncore
import socket
import threading

from users import Users
from titlefetcher import TitleFetcher
from log import log

class ClientHandler( asyncore.dispatcher ):

    def __init__( self, socket, config ):
        asyncore.dispatcher.__init__( self, socket )
        self.name = None
        self.mutex = threading.Lock()
        self.buffer = ''
        self.config = config

    def setUsers( self, users ):
        self.users = users

    def welcome( self ):
        self.write_data( 'ChatServ v1.0\n\n{0}\n\nInsert your name: '.format( self.config.welcome ) )

    def handle_read( self ):
        data = self.recv( 8192 )

        if data:
            if self.name is None:
                list = data.split( None, 1 )
                if len( list ) == 0:
                    return
                elif len( list ) == 1:
                    self.name = list[ 0 ]
                    data = ''
                else:
                    self.name = list[ 0 ]
                    data = len[ 1 ]
                try:
                    self.users.addUser( self.name, self )
                except UserMap.Error as ex:
                    self.name = None
                    self._exitConnection( str( ex ) )
                    return

        if data:
            self.users.message( self.name, data )

    def write_data( self, data ):
        self.mutex.acquire()
        self.buffer += data
        self.mutex.release()

    def handle_close( self ):
        if self.name is not None:
            self.users.removeUser( self.name )
        self.disconnect()

    def disconnect( self ):
        while self.writable():
            self.handle_write()
        self.close()

    def handle_write( self ):
        self.mutex.acquire()
        sent = self.send( self.buffer )
        self.buffer = self.buffer[ sent: ]
        self.mutex.release()

    def writable( self ):
        try:
            self.mutex.acquire()
            return len( self.buffer ) > 0
        finally:
            self.mutex.release()

    def _exitConnection( self, reason ):
        msg = '[SRV]: Connection refused: {0}\n'.format( reason )
        self.write_data( msg )
        log( msg )
        self.handle_close()

class ConnectionDispatcher( asyncore.dispatcher ):

    def __init__( self, config ):
        asyncore.dispatcher.__init__( self )
        self.create_socket( socket.AF_INET, socket.SOCK_STREAM )
        self.set_reuse_addr()
        self.bind( (config.host, config.port) )
        self.listen( 5 )
        self.config = config

        log( 'Server is running at {0}:{1}\n'.format( config.host, config.port ) )
        log( 'Maximum number of users is {0}\n'.format( config.limit ) )

    def setUsers( self, users ):
        self.users = users

    def handle_accept( self ):
        pair = self.accept()
        if pair is not None:
            sock, addr = pair
            log( '[SRV]: Incoming connection from {0}\n'.format( repr( addr ) ) )
            handler = ClientHandler( sock, self.config )
            handler.setUsers( self.users )
            handler.welcome()

class Server( object ):

    def __init__( self, config ):
        self.config = config

    def run( self ):
        users = Users( self.config.limit )
        titleFetcher = TitleFetcher()

        users.setFetcher( titleFetcher )
        titleFetcher.setUsers( users )

        try:
            server = ConnectionDispatcher( self.config )
        except:
            log( 'Cannot start server: {0}:{1} is already in use.\n'.format( self.config.host, self.config.port ) )
            return
        server.setUsers( users )

        titleFetcher.start()

        try:
            asyncore.loop( 0.1 )
        except KeyboardInterrupt:
            users.message( '[SRV]', 'server is shutting down\n' )
            users.report = False

        titleFetcher.join()
        users.disconnectAll()