FilesExpand file tree

 master

/

base_manager.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

151 lines (132 loc) · 5.63 KB

 master

/

base_manager.py

Copy path

Top

File metadata and controls

• Code
• Blame

151 lines (132 loc) · 5.63 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

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

138

139

140

141

142

143

144

145

146

147

148

149

150

151

import itertools

import six

class BaseManager(object):

"""Manage client connections.

This class keeps track of all the clients and the rooms they are in, to

support the broadcasting of messages. The data used by this class is

stored in a memory structure, making it appropriate only for single process

services. More sophisticated storage backends can be implemented by

subclasses.

"""

def __init__(self):

self.server = None

self.rooms = {}

self.callbacks = {}

self.pending_disconnect = {}

def initialize(self, server):

self.server = server

def get_namespaces(self):

"""Return an iterable with the active namespace names."""

return six.iterkeys(self.rooms)

def get_participants(self, namespace, room):

"""Return an iterable with the active participants in a room."""

for sid, active in six.iteritems(self.rooms[namespace][room].copy()):

yield sid

def connect(self, sid, namespace):

"""Register a client connection to a namespace."""

self.enter_room(sid, namespace, None)

self.enter_room(sid, namespace, sid)

def is_connected(self, sid, namespace):

if namespace in self.pending_disconnect and \

sid in self.pending_disconnect[namespace]:

# the client is in the process of being disconnected

return False

try:

return self.rooms[namespace][None][sid]

except KeyError:

pass

def pre_disconnect(self, sid, namespace):

"""Put the client in the to-be-disconnected list.

This allows the client data structures to be present while the

disconnect handler is invoked, but still recognize the fact that the

client is soon going away.

"""

if namespace not in self.pending_disconnect:

self.pending_disconnect[namespace] = []

self.pending_disconnect[namespace].append(sid)

def disconnect(self, sid, namespace):

"""Register a client disconnect from a namespace."""

rooms = []

for room_name, room in six.iteritems(self.rooms[namespace]):

if sid in room:

rooms.append(room_name)

for room in rooms:

self.leave_room(sid, namespace, room)

if sid in self.callbacks and namespace in self.callbacks[sid]:

del self.callbacks[sid][namespace]

if len(self.callbacks[sid]) == 0:

del self.callbacks[sid]

if namespace in self.pending_disconnect and \

sid in self.pending_disconnect[namespace]:

self.pending_disconnect[namespace].remove(sid)

if len(self.pending_disconnect[namespace]) == 0:

del self.pending_disconnect[namespace]

def enter_room(self, sid, namespace, room):

"""Add a client to a room."""

if namespace not in self.rooms:

self.rooms[namespace] = {}

if room not in self.rooms[namespace]:

self.rooms[namespace][room] = {}

self.rooms[namespace][room][sid] = True

def leave_room(self, sid, namespace, room):

"""Remove a client from a room."""

try:

del self.rooms[namespace][room][sid]

if len(self.rooms[namespace][room]) == 0:

del self.rooms[namespace][room]

if len(self.rooms[namespace]) == 0:

del self.rooms[namespace]

except KeyError:

pass

def close_room(self, room, namespace):

"""Remove all participants from a room."""

try:

for sid in self.get_participants(namespace, room):

self.leave_room(sid, namespace, room)

except KeyError:

pass

def get_rooms(self, sid, namespace):

"""Return the rooms a client is in."""

r = []

try:

for room_name, room in six.iteritems(self.rooms[namespace]):

if room_name is not None and sid in room and room[sid]:

r.append(room_name)

except KeyError:

pass

return r

def emit(self, event, data, namespace, room=None, skip_sid=None,

callback=None, **kwargs):

"""Emit a message to a single client, a room, or all the clients

connected to the namespace."""

if namespace not in self.rooms or room not in self.rooms[namespace]:

return

for sid in self.get_participants(namespace, room):

if sid != skip_sid:

if callback is not None:

id = self._generate_ack_id(sid, namespace, callback)

else:

id = None

self.server._emit_internal(sid, event, data, namespace, id)

def trigger_callback(self, sid, namespace, id, data):

"""Invoke an application callback."""

callback = None

try:

callback = self.callbacks[sid][namespace][id]

except KeyError:

# if we get an unknown callback we just ignore it

self.server.logger.warning('Unknown callback received, ignoring.')

else:

del self.callbacks[sid][namespace][id]

if callback is not None:

callback(*data)

def _generate_ack_id(self, sid, namespace, callback):

"""Generate a unique identifier for an ACK packet."""

namespace = namespace or '/'

if sid not in self.callbacks:

self.callbacks[sid] = {}

if namespace not in self.callbacks[sid]:

self.callbacks[sid][namespace] = {0: itertools.count(1)}

id = six.next(self.callbacks[sid][namespace][0])

self.callbacks[sid][namespace][id] = callback

return id