0
# Server Management
1

2
Server instances that manage Redis state, databases, and connections with support for different Redis-compatible server types. FakeServer provides the central coordination for all Redis operations and maintains consistency across multiple clients.
3

4
## Capabilities
5

6
### Core Server Management
7

8
Central server instance that manages databases, script cache, pub/sub subscribers, and connection state.
9

10
```python { .api }
11
class FakeServer:
12
    def __init__(
13
        self,
14
        version: VersionType = (7,),
15
        server_type: ServerType = "redis", 
16
        config: Optional[Dict[bytes, bytes]] = None
17
    ): ...
18
    
19
    @property
20
    def connected(self) -> bool: ...
21
    
22
    @property
23
    def lock(self) -> threading.RLock: ...
24
    
25
    def get_server(self) -> FakeServer: ...
26
    def get_next_client_id(self) -> int: ...
27
    def flush_all(self) -> None: ...
28
    def save(self) -> None: ...
29
    def shutdown(self) -> None: ...
30
```
31

32
### TCP Server Implementation
33

34
Full TCP server implementation for network testing with Redis protocol support and multi-threaded connection handling.
35

36
```python { .api }
37
class TcpFakeServer(ThreadingTCPServer):
38
    def __init__(
39
        self,
40
        server_address: Tuple[str, int],
41
        server_type: ServerType = "redis",
42
        server_version: VersionType = (8, 0),
43
        RequestHandlerClass: type = StreamRequestHandler
44
    ): ...
45
    
46
    def server_bind(self) -> None: ...
47
    def server_activate(self) -> None: ...
48
    def shutdown(self) -> None: ...
49
    def get_server(self) -> FakeServer: ...
50
```
51

52
## Usage Examples
53

54
### Basic Server Usage
55

56
```python
57
import fakeredis
58

59
# Create a server with default settings (Redis 7.0)
60
server = fakeredis.FakeServer()
61

62
# Create clients that share the same server
63
client1 = fakeredis.FakeRedis(server=server)
64
client2 = fakeredis.FakeRedis(server=server)
65

66
# Both clients operate on the same data
67
client1.set('shared_key', 'value')
68
result = client2.get('shared_key')  # Returns b'value'
69
```
70

71
### Version Configuration
72

73
```python
74
import fakeredis
75

76
# Configure for specific Redis versions
77
redis_6_server = fakeredis.FakeServer(version=(6, 2, 7))
78
redis_7_server = fakeredis.FakeServer(version=(7, 0, 5))
79
redis_8_server = fakeredis.FakeServer(version=(8, 0))
80

81
# Clients inherit server version behavior
82
client_v6 = fakeredis.FakeRedis(server=redis_6_server)
83
client_v7 = fakeredis.FakeRedis(server=redis_7_server)
84
```
85

86
### Server Type Configuration
87

88
```python
89
import fakeredis
90

91
# Configure for different server types
92
redis_server = fakeredis.FakeServer(server_type="redis")
93
dragonfly_server = fakeredis.FakeServer(server_type="dragonfly")
94
valkey_server = fakeredis.FakeServer(server_type="valkey")
95

96
# Server type affects command behavior and compatibility
97
dragonfly_client = fakeredis.FakeRedis(server=dragonfly_server)
98
# Now supports Dragonfly-specific commands like SADDEX
99
```
100

101
### Server Configuration
102

103
```python
104
import fakeredis
105

106
# Configure server with Redis-style config
107
config = {
108
    b'requirepass': b'mypassword',
109
    b'maxmemory': b'1gb',
110
    b'maxmemory-policy': b'allkeys-lru',
111
    b'save': b'900 1 300 10'
112
}
113

114
server = fakeredis.FakeServer(config=config)
115
client = fakeredis.FakeRedis(server=server)
116

117
# Client must authenticate
118
try:
119
    client.set('key', 'value')  # Will fail without auth
120
except redis.AuthenticationError:
121
    pass
122

123
# Authenticate first
124
client.auth('mypassword')
125
client.set('key', 'value')  # Now works
126
```
127

128
### TCP Server for Network Testing
129

130
```python
131
import fakeredis
132
import redis
133
import threading
134
import time
135

136
# Start a TCP server on localhost:6380
137
tcp_server = fakeredis.TcpFakeServer(
138
    ('localhost', 6380),
139
    server_type="redis", 
140
    server_version=(7, 0)
141
)
142

143
# Run server in background thread
144
server_thread = threading.Thread(target=tcp_server.serve_forever)
145
server_thread.daemon = True
146
server_thread.start()
147

148
# Connect with regular redis-py client
149
real_client = redis.Redis(host='localhost', port=6380, decode_responses=True)
150

151
# Test network operations
152
real_client.set('network_key', 'network_value')
153
result = real_client.get('network_key')
154
print(f"Result from TCP server: {result}")
155

156
# Shutdown server
157
tcp_server.shutdown()
158
```
159

160
### Multiple Isolated Servers
161

162
```python
163
import fakeredis
164

165
# Create isolated servers for different test scenarios
166
test_server_1 = fakeredis.FakeServer()
167
test_server_2 = fakeredis.FakeServer()
168

169
# Each server maintains separate data
170
client_1a = fakeredis.FakeRedis(server=test_server_1)
171
client_1b = fakeredis.FakeRedis(server=test_server_1)  # Shares with 1a
172

173
client_2a = fakeredis.FakeRedis(server=test_server_2)  # Isolated from server 1
174

175
# Operations on different servers are independent
176
client_1a.set('key', 'value1')
177
client_2a.set('key', 'value2')
178

179
print(client_1b.get('key').decode())  # 'value1' (same server as 1a)
180
print(client_2a.get('key').decode())  # 'value2' (different server)
181
```
182

183
### Server State Management
184

185
```python
186
import fakeredis
187

188
server = fakeredis.FakeServer()
189
client = fakeredis.FakeRedis(server=server)
190

191
# Add some data
192
client.set('key1', 'value1')
193
client.set('key2', 'value2')
194
client.lpush('list', 'item1', 'item2')
195

196
# Check server connection state
197
print(f"Server connected: {server.connected}")  # True
198

199
# Flush all data
200
server.flush_all()
201
print(f"Keys after flush: {client.keys()}")  # []
202

203
# Shutdown server (disconnects all clients)
204
server.shutdown()
205
print(f"Server connected: {server.connected}")  # False
206
```
207

208
### Server with Custom Database Count
209

210
```python
211
import fakeredis
212

213
# Create server with specific database configuration
214
config = {
215
    b'databases': b'32'  # Support 32 databases (default is 16)
216
}
217

218
server = fakeredis.FakeServer(config=config)
219

220
# Create clients for different databases
221
client_db0 = fakeredis.FakeRedis(server=server, db=0)
222
client_db15 = fakeredis.FakeRedis(server=server, db=15)
223
client_db31 = fakeredis.FakeRedis(server=server, db=31)
224

225
# Each database is isolated
226
client_db0.set('key', 'db0_value')
227
client_db15.set('key', 'db15_value')
228

229
print(client_db0.get('key').decode())   # 'db0_value'
230
print(client_db15.get('key').decode())  # 'db15_value'
231
print(client_db31.get('key'))           # None (not set)
232
```