pondsocket 0.0.1__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- pondsocket/__init__.py +205 -0
- pondsocket/channel.py +580 -0
- pondsocket/contexts/__init__.py +16 -0
- pondsocket/contexts/connection_context.py +135 -0
- pondsocket/contexts/event_context.py +127 -0
- pondsocket/contexts/join_context.py +162 -0
- pondsocket/contexts/leave_context.py +78 -0
- pondsocket/contexts/outgoing_context.py +72 -0
- pondsocket/distributed/__init__.py +5 -0
- pondsocket/distributed/redis_pubsub.py +137 -0
- pondsocket/endpoint.py +348 -0
- pondsocket/errors.py +90 -0
- pondsocket/hooks.py +227 -0
- pondsocket/in_memory_transport.py +112 -0
- pondsocket/lobby.py +183 -0
- pondsocket/middleware.py +100 -0
- pondsocket/parser.py +85 -0
- pondsocket/presence.py +109 -0
- pondsocket/pubsub.py +44 -0
- pondsocket/pubsub_local.py +85 -0
- pondsocket/py.typed +0 -0
- pondsocket/server.py +88 -0
- pondsocket/sse_transport.py +122 -0
- pondsocket/store.py +83 -0
- pondsocket/transport.py +29 -0
- pondsocket/types.py +154 -0
- pondsocket/wire.py +87 -0
- pondsocket-0.0.1.dist-info/METADATA +144 -0
- pondsocket-0.0.1.dist-info/RECORD +30 -0
- pondsocket-0.0.1.dist-info/WHEEL +4 -0
pondsocket/hooks.py
ADDED
|
@@ -0,0 +1,227 @@
|
|
|
1
|
+
from __future__ import annotations
|
|
2
|
+
|
|
3
|
+
import asyncio
|
|
4
|
+
import time
|
|
5
|
+
from collections.abc import Awaitable, Callable
|
|
6
|
+
from dataclasses import dataclass
|
|
7
|
+
from typing import TYPE_CHECKING, Protocol, TypeAlias, runtime_checkable
|
|
8
|
+
|
|
9
|
+
from .errors import too_many_requests
|
|
10
|
+
from .types import Event, MessageEvent, User
|
|
11
|
+
|
|
12
|
+
if TYPE_CHECKING:
|
|
13
|
+
from .channel import Channel
|
|
14
|
+
from .transport import Transport
|
|
15
|
+
|
|
16
|
+
|
|
17
|
+
@runtime_checkable
|
|
18
|
+
class RateLimiter(Protocol):
|
|
19
|
+
async def allow(self, key: str) -> bool: ...
|
|
20
|
+
async def reset(self, key: str) -> None: ...
|
|
21
|
+
|
|
22
|
+
|
|
23
|
+
@runtime_checkable
|
|
24
|
+
class MetricsCollector(Protocol):
|
|
25
|
+
def connection_opened(self, conn_id: str, endpoint: str) -> None: ...
|
|
26
|
+
def connection_closed(self, conn_id: str, duration_seconds: float) -> None: ...
|
|
27
|
+
def connection_error(self, conn_id: str, err: BaseException) -> None: ...
|
|
28
|
+
def message_received(
|
|
29
|
+
self, conn_id: str, channel: str, event: str, size: int
|
|
30
|
+
) -> None: ...
|
|
31
|
+
def message_sent(
|
|
32
|
+
self, conn_id: str, channel: str, event: str, size: int
|
|
33
|
+
) -> None: ...
|
|
34
|
+
def message_broadcast(
|
|
35
|
+
self, channel: str, event: str, recipient_count: int
|
|
36
|
+
) -> None: ...
|
|
37
|
+
def channel_joined(self, user_id: str, channel: str) -> None: ...
|
|
38
|
+
def channel_left(self, user_id: str, channel: str) -> None: ...
|
|
39
|
+
def channel_created(self, channel: str) -> None: ...
|
|
40
|
+
def channel_destroyed(self, channel: str) -> None: ...
|
|
41
|
+
def handler_duration(self, handler: str, duration_seconds: float) -> None: ...
|
|
42
|
+
def queue_depth(self, queue: str, depth: int) -> None: ...
|
|
43
|
+
def error(self, component: str, err: BaseException) -> None: ...
|
|
44
|
+
|
|
45
|
+
|
|
46
|
+
class NoopMetrics:
|
|
47
|
+
__slots__ = ()
|
|
48
|
+
|
|
49
|
+
def connection_opened(self, conn_id: str, endpoint: str) -> None:
|
|
50
|
+
return
|
|
51
|
+
|
|
52
|
+
def connection_closed(self, conn_id: str, duration_seconds: float) -> None:
|
|
53
|
+
return
|
|
54
|
+
|
|
55
|
+
def connection_error(self, conn_id: str, err: BaseException) -> None:
|
|
56
|
+
return
|
|
57
|
+
|
|
58
|
+
def message_received(
|
|
59
|
+
self, conn_id: str, channel: str, event: str, size: int
|
|
60
|
+
) -> None:
|
|
61
|
+
return
|
|
62
|
+
|
|
63
|
+
def message_sent(
|
|
64
|
+
self, conn_id: str, channel: str, event: str, size: int
|
|
65
|
+
) -> None:
|
|
66
|
+
return
|
|
67
|
+
|
|
68
|
+
def message_broadcast(
|
|
69
|
+
self, channel: str, event: str, recipient_count: int
|
|
70
|
+
) -> None:
|
|
71
|
+
return
|
|
72
|
+
|
|
73
|
+
def channel_joined(self, user_id: str, channel: str) -> None:
|
|
74
|
+
return
|
|
75
|
+
|
|
76
|
+
def channel_left(self, user_id: str, channel: str) -> None:
|
|
77
|
+
return
|
|
78
|
+
|
|
79
|
+
def channel_created(self, channel: str) -> None:
|
|
80
|
+
return
|
|
81
|
+
|
|
82
|
+
def channel_destroyed(self, channel: str) -> None:
|
|
83
|
+
return
|
|
84
|
+
|
|
85
|
+
def handler_duration(self, handler: str, duration_seconds: float) -> None:
|
|
86
|
+
return
|
|
87
|
+
|
|
88
|
+
def queue_depth(self, queue: str, depth: int) -> None:
|
|
89
|
+
return
|
|
90
|
+
|
|
91
|
+
def error(self, component: str, err: BaseException) -> None:
|
|
92
|
+
return
|
|
93
|
+
|
|
94
|
+
|
|
95
|
+
OnConnect: TypeAlias = Callable[["Transport"], Awaitable[None]]
|
|
96
|
+
OnDisconnect: TypeAlias = Callable[["Transport"], Awaitable[None]]
|
|
97
|
+
BeforeJoin: TypeAlias = Callable[[User, str], Awaitable[None]]
|
|
98
|
+
AfterJoin: TypeAlias = Callable[[User, str], Awaitable[None]]
|
|
99
|
+
BeforeMessage: TypeAlias = Callable[[Event], Awaitable[None]]
|
|
100
|
+
AfterMessage: TypeAlias = Callable[[Event, BaseException | None], Awaitable[None]]
|
|
101
|
+
|
|
102
|
+
|
|
103
|
+
@dataclass(slots=True)
|
|
104
|
+
class Hooks:
|
|
105
|
+
rate_limiter: RateLimiter | None = None
|
|
106
|
+
channel_rate_limiter: RateLimiter | None = None
|
|
107
|
+
metrics: MetricsCollector | None = None
|
|
108
|
+
on_connect: OnConnect | None = None
|
|
109
|
+
on_disconnect: OnDisconnect | None = None
|
|
110
|
+
before_join: BeforeJoin | None = None
|
|
111
|
+
after_join: AfterJoin | None = None
|
|
112
|
+
before_message: BeforeMessage | None = None
|
|
113
|
+
after_message: AfterMessage | None = None
|
|
114
|
+
|
|
115
|
+
|
|
116
|
+
@dataclass(slots=True)
|
|
117
|
+
class _Bucket:
|
|
118
|
+
tokens: float
|
|
119
|
+
last_refill: float
|
|
120
|
+
|
|
121
|
+
|
|
122
|
+
class TokenBucketRateLimiter:
|
|
123
|
+
__slots__ = ("_buckets", "_capacity", "_lock", "_rate")
|
|
124
|
+
|
|
125
|
+
def __init__(self, *, rate: float, capacity: float) -> None:
|
|
126
|
+
if rate <= 0:
|
|
127
|
+
raise ValueError("rate must be > 0")
|
|
128
|
+
if capacity <= 0:
|
|
129
|
+
raise ValueError("capacity must be > 0")
|
|
130
|
+
self._rate = rate
|
|
131
|
+
self._capacity = capacity
|
|
132
|
+
self._buckets: dict[str, _Bucket] = {}
|
|
133
|
+
self._lock = asyncio.Lock()
|
|
134
|
+
|
|
135
|
+
@property
|
|
136
|
+
def rate(self) -> float:
|
|
137
|
+
return self._rate
|
|
138
|
+
|
|
139
|
+
@property
|
|
140
|
+
def capacity(self) -> float:
|
|
141
|
+
return self._capacity
|
|
142
|
+
|
|
143
|
+
async def allow(self, key: str) -> bool:
|
|
144
|
+
async with self._lock:
|
|
145
|
+
now = time.monotonic()
|
|
146
|
+
bucket = self._buckets.get(key)
|
|
147
|
+
if bucket is None:
|
|
148
|
+
bucket = _Bucket(tokens=self._capacity, last_refill=now)
|
|
149
|
+
self._buckets[key] = bucket
|
|
150
|
+
elapsed = now - bucket.last_refill
|
|
151
|
+
bucket.tokens = min(self._capacity, bucket.tokens + elapsed * self._rate)
|
|
152
|
+
bucket.last_refill = now
|
|
153
|
+
if bucket.tokens >= 1.0:
|
|
154
|
+
bucket.tokens -= 1.0
|
|
155
|
+
return True
|
|
156
|
+
return False
|
|
157
|
+
|
|
158
|
+
async def reset(self, key: str) -> None:
|
|
159
|
+
async with self._lock:
|
|
160
|
+
self._buckets.pop(key, None)
|
|
161
|
+
|
|
162
|
+
async def reset_all(self) -> None:
|
|
163
|
+
async with self._lock:
|
|
164
|
+
self._buckets.clear()
|
|
165
|
+
|
|
166
|
+
|
|
167
|
+
def with_rate_limiter(
|
|
168
|
+
hooks: Hooks,
|
|
169
|
+
key_fn: Callable[[MessageEvent], str],
|
|
170
|
+
) -> Callable[
|
|
171
|
+
[MessageEvent, Channel, Callable[[], Awaitable[None]]],
|
|
172
|
+
Awaitable[None],
|
|
173
|
+
]:
|
|
174
|
+
async def middleware(
|
|
175
|
+
message: MessageEvent,
|
|
176
|
+
_channel: Channel,
|
|
177
|
+
nxt: Callable[[], Awaitable[None]],
|
|
178
|
+
) -> None:
|
|
179
|
+
if hooks.rate_limiter is None:
|
|
180
|
+
await nxt()
|
|
181
|
+
return
|
|
182
|
+
key = key_fn(message)
|
|
183
|
+
allowed = await hooks.rate_limiter.allow(key)
|
|
184
|
+
if not allowed:
|
|
185
|
+
err = too_many_requests(
|
|
186
|
+
message.event.channel_name, "Rate limit exceeded"
|
|
187
|
+
)
|
|
188
|
+
if hooks.metrics is not None:
|
|
189
|
+
hooks.metrics.error("rate_limiter", err)
|
|
190
|
+
raise err
|
|
191
|
+
await nxt()
|
|
192
|
+
|
|
193
|
+
return middleware
|
|
194
|
+
|
|
195
|
+
|
|
196
|
+
def with_metrics(
|
|
197
|
+
hooks: Hooks,
|
|
198
|
+
) -> Callable[
|
|
199
|
+
[MessageEvent, Channel, Callable[[], Awaitable[None]]],
|
|
200
|
+
Awaitable[None],
|
|
201
|
+
]:
|
|
202
|
+
async def middleware(
|
|
203
|
+
message: MessageEvent,
|
|
204
|
+
_channel: Channel,
|
|
205
|
+
nxt: Callable[[], Awaitable[None]],
|
|
206
|
+
) -> None:
|
|
207
|
+
if hooks.metrics is None:
|
|
208
|
+
await nxt()
|
|
209
|
+
return
|
|
210
|
+
metrics = hooks.metrics
|
|
211
|
+
start = time.monotonic()
|
|
212
|
+
try:
|
|
213
|
+
await nxt()
|
|
214
|
+
except Exception as e:
|
|
215
|
+
metrics.error("message_handler", e)
|
|
216
|
+
raise
|
|
217
|
+
finally:
|
|
218
|
+
duration = time.monotonic() - start
|
|
219
|
+
metrics.message_received(
|
|
220
|
+
message.user.id,
|
|
221
|
+
message.event.channel_name,
|
|
222
|
+
message.event.event,
|
|
223
|
+
0,
|
|
224
|
+
)
|
|
225
|
+
metrics.handler_duration(message.event.event, duration)
|
|
226
|
+
|
|
227
|
+
return middleware
|
|
@@ -0,0 +1,112 @@
|
|
|
1
|
+
from __future__ import annotations
|
|
2
|
+
|
|
3
|
+
import asyncio
|
|
4
|
+
from typing import Any
|
|
5
|
+
|
|
6
|
+
from .errors import internal
|
|
7
|
+
from .transport import OnCloseCallback, OnMessageHandler
|
|
8
|
+
from .types import Event, TransportType
|
|
9
|
+
|
|
10
|
+
|
|
11
|
+
class InMemoryTransport:
|
|
12
|
+
__slots__ = (
|
|
13
|
+
"_active",
|
|
14
|
+
"_assigns",
|
|
15
|
+
"_close_callbacks",
|
|
16
|
+
"_id",
|
|
17
|
+
"_inbox",
|
|
18
|
+
"_lock",
|
|
19
|
+
"_message_handler",
|
|
20
|
+
"_outbox",
|
|
21
|
+
"_receive_task",
|
|
22
|
+
)
|
|
23
|
+
|
|
24
|
+
def __init__(self, id: str, *, assigns: dict[str, Any] | None = None) -> None:
|
|
25
|
+
self._id = id
|
|
26
|
+
self._assigns: dict[str, Any] = dict(assigns or {})
|
|
27
|
+
self._active = True
|
|
28
|
+
self._outbox: asyncio.Queue[Event] = asyncio.Queue()
|
|
29
|
+
self._inbox: asyncio.Queue[Event] = asyncio.Queue()
|
|
30
|
+
self._close_callbacks: list[OnCloseCallback] = []
|
|
31
|
+
self._message_handler: OnMessageHandler | None = None
|
|
32
|
+
self._receive_task: asyncio.Task[None] | None = None
|
|
33
|
+
self._lock = asyncio.Lock()
|
|
34
|
+
|
|
35
|
+
def get_id(self) -> str:
|
|
36
|
+
return self._id
|
|
37
|
+
|
|
38
|
+
async def send_event(self, event: Event) -> None:
|
|
39
|
+
if not self._active:
|
|
40
|
+
raise internal("", "Transport is closed")
|
|
41
|
+
await self._outbox.put(event)
|
|
42
|
+
|
|
43
|
+
def get_assign(self, key: str) -> Any:
|
|
44
|
+
return self._assigns.get(key)
|
|
45
|
+
|
|
46
|
+
def set_assign(self, key: str, value: Any) -> None:
|
|
47
|
+
self._assigns[key] = value
|
|
48
|
+
|
|
49
|
+
def clone_assigns(self) -> dict[str, Any]:
|
|
50
|
+
return dict(self._assigns)
|
|
51
|
+
|
|
52
|
+
def is_active(self) -> bool:
|
|
53
|
+
return self._active
|
|
54
|
+
|
|
55
|
+
async def close(self) -> None:
|
|
56
|
+
if not self._active:
|
|
57
|
+
return
|
|
58
|
+
self._active = False
|
|
59
|
+
if self._receive_task is not None and not self._receive_task.done():
|
|
60
|
+
self._receive_task.cancel()
|
|
61
|
+
for cb in list(self._close_callbacks):
|
|
62
|
+
try:
|
|
63
|
+
await cb(self)
|
|
64
|
+
except Exception:
|
|
65
|
+
continue
|
|
66
|
+
|
|
67
|
+
def on_close(self, callback: OnCloseCallback) -> None:
|
|
68
|
+
self._close_callbacks.append(callback)
|
|
69
|
+
|
|
70
|
+
def on_message(self, handler: OnMessageHandler) -> None:
|
|
71
|
+
self._message_handler = handler
|
|
72
|
+
|
|
73
|
+
async def handle_messages(self) -> None:
|
|
74
|
+
if self._message_handler is None:
|
|
75
|
+
raise RuntimeError("on_message must be set before handle_messages")
|
|
76
|
+
if self._receive_task is not None and not self._receive_task.done():
|
|
77
|
+
return
|
|
78
|
+
self._receive_task = asyncio.create_task(self._receive_loop())
|
|
79
|
+
|
|
80
|
+
async def _receive_loop(self) -> None:
|
|
81
|
+
assert self._message_handler is not None
|
|
82
|
+
while True:
|
|
83
|
+
try:
|
|
84
|
+
ev = await self._inbox.get()
|
|
85
|
+
except asyncio.CancelledError:
|
|
86
|
+
return
|
|
87
|
+
if not self._active:
|
|
88
|
+
return
|
|
89
|
+
try:
|
|
90
|
+
await self._message_handler(ev, self)
|
|
91
|
+
except Exception:
|
|
92
|
+
continue
|
|
93
|
+
|
|
94
|
+
def transport_type(self) -> TransportType:
|
|
95
|
+
return TransportType.WEBSOCKET
|
|
96
|
+
|
|
97
|
+
async def receive_sent(self, *, wait: float | None = 1.0) -> Event:
|
|
98
|
+
if wait is None:
|
|
99
|
+
return await self._outbox.get()
|
|
100
|
+
return await asyncio.wait_for(self._outbox.get(), wait)
|
|
101
|
+
|
|
102
|
+
async def push_inbound(self, event: Event) -> None:
|
|
103
|
+
await self._inbox.put(event)
|
|
104
|
+
|
|
105
|
+
def outbox_size(self) -> int:
|
|
106
|
+
return self._outbox.qsize()
|
|
107
|
+
|
|
108
|
+
async def drain_outbox(self) -> list[Event]:
|
|
109
|
+
events: list[Event] = []
|
|
110
|
+
while not self._outbox.empty():
|
|
111
|
+
events.append(self._outbox.get_nowait())
|
|
112
|
+
return events
|
pondsocket/lobby.py
ADDED
|
@@ -0,0 +1,183 @@
|
|
|
1
|
+
from __future__ import annotations
|
|
2
|
+
|
|
3
|
+
import asyncio
|
|
4
|
+
from collections.abc import Awaitable, Callable
|
|
5
|
+
from typing import TypeAlias
|
|
6
|
+
|
|
7
|
+
from .channel import Channel, ChannelOptions, LeaveMiddlewareFn
|
|
8
|
+
from .contexts.event_context import EventContext
|
|
9
|
+
from .contexts.leave_context import LeaveContext
|
|
10
|
+
from .contexts.outgoing_context import OutgoingContext
|
|
11
|
+
from .errors import PondError
|
|
12
|
+
from .middleware import Middleware, execute_with_middleware
|
|
13
|
+
from .parser import parse
|
|
14
|
+
from .pubsub import PubSub
|
|
15
|
+
from .types import MessageEvent, Options
|
|
16
|
+
|
|
17
|
+
EventHandler: TypeAlias = Callable[[EventContext], Awaitable[None]]
|
|
18
|
+
LeaveHandler: TypeAlias = Callable[[LeaveContext], Awaitable[None]]
|
|
19
|
+
OutgoingHandler: TypeAlias = Callable[[OutgoingContext], Awaitable[None]]
|
|
20
|
+
|
|
21
|
+
EventMiddlewareFn: TypeAlias = Callable[
|
|
22
|
+
[EventContext, Callable[[], Awaitable[None]]], Awaitable[None]
|
|
23
|
+
]
|
|
24
|
+
OutgoingMiddlewareFn: TypeAlias = Callable[
|
|
25
|
+
[OutgoingContext, Callable[[], Awaitable[None]]], Awaitable[None]
|
|
26
|
+
]
|
|
27
|
+
|
|
28
|
+
|
|
29
|
+
class Lobby:
|
|
30
|
+
__slots__ = (
|
|
31
|
+
"_channels",
|
|
32
|
+
"_endpoint_path",
|
|
33
|
+
"_leave_handler",
|
|
34
|
+
"_leave_middlewares",
|
|
35
|
+
"_lock",
|
|
36
|
+
"_message_middleware",
|
|
37
|
+
"_options",
|
|
38
|
+
"_outgoing_middleware",
|
|
39
|
+
"_path",
|
|
40
|
+
"_pubsub",
|
|
41
|
+
)
|
|
42
|
+
|
|
43
|
+
def __init__(
|
|
44
|
+
self,
|
|
45
|
+
*,
|
|
46
|
+
path: str,
|
|
47
|
+
endpoint_path: str = "",
|
|
48
|
+
options: Options | None = None,
|
|
49
|
+
pubsub: PubSub | None = None,
|
|
50
|
+
) -> None:
|
|
51
|
+
self._path = path
|
|
52
|
+
self._endpoint_path = endpoint_path
|
|
53
|
+
self._options = options or Options()
|
|
54
|
+
self._pubsub = pubsub
|
|
55
|
+
self._channels: dict[str, Channel] = {}
|
|
56
|
+
self._message_middleware: Middleware[MessageEvent, Channel] = Middleware()
|
|
57
|
+
self._outgoing_middleware: Middleware[OutgoingContext, None] = Middleware()
|
|
58
|
+
self._leave_handler: LeaveHandler | None = None
|
|
59
|
+
self._leave_middlewares: list[LeaveMiddlewareFn] = []
|
|
60
|
+
self._lock = asyncio.Lock()
|
|
61
|
+
|
|
62
|
+
@property
|
|
63
|
+
def path(self) -> str:
|
|
64
|
+
return self._path
|
|
65
|
+
|
|
66
|
+
@property
|
|
67
|
+
def options(self) -> Options:
|
|
68
|
+
return self._options
|
|
69
|
+
|
|
70
|
+
def on_message(
|
|
71
|
+
self,
|
|
72
|
+
event_pattern: str,
|
|
73
|
+
handler: EventHandler,
|
|
74
|
+
*middlewares: EventMiddlewareFn,
|
|
75
|
+
) -> None:
|
|
76
|
+
chain = list(middlewares)
|
|
77
|
+
|
|
78
|
+
async def wrapper(
|
|
79
|
+
req: MessageEvent,
|
|
80
|
+
resp: Channel,
|
|
81
|
+
nxt: Callable[[], Awaitable[None]],
|
|
82
|
+
) -> None:
|
|
83
|
+
try:
|
|
84
|
+
route = parse(event_pattern, req.event.event)
|
|
85
|
+
except PondError:
|
|
86
|
+
await nxt()
|
|
87
|
+
return
|
|
88
|
+
ctx = EventContext(channel=resp, message=req, route=route)
|
|
89
|
+
await execute_with_middleware(ctx, handler, chain)
|
|
90
|
+
|
|
91
|
+
self._message_middleware.use_sync(wrapper)
|
|
92
|
+
|
|
93
|
+
def on_leave(
|
|
94
|
+
self,
|
|
95
|
+
handler: LeaveHandler,
|
|
96
|
+
*middlewares: LeaveMiddlewareFn,
|
|
97
|
+
) -> None:
|
|
98
|
+
self._leave_handler = handler
|
|
99
|
+
self._leave_middlewares = list(middlewares)
|
|
100
|
+
|
|
101
|
+
def on_outgoing(
|
|
102
|
+
self,
|
|
103
|
+
event_pattern: str,
|
|
104
|
+
handler: OutgoingHandler,
|
|
105
|
+
*middlewares: OutgoingMiddlewareFn,
|
|
106
|
+
) -> None:
|
|
107
|
+
chain = list(middlewares)
|
|
108
|
+
|
|
109
|
+
async def wrapper(
|
|
110
|
+
req: OutgoingContext,
|
|
111
|
+
_resp: None,
|
|
112
|
+
nxt: Callable[[], Awaitable[None]],
|
|
113
|
+
) -> None:
|
|
114
|
+
try:
|
|
115
|
+
route = parse(event_pattern, req.event.event)
|
|
116
|
+
except PondError:
|
|
117
|
+
await nxt()
|
|
118
|
+
return
|
|
119
|
+
req.route = route
|
|
120
|
+
await execute_with_middleware(req, handler, chain)
|
|
121
|
+
|
|
122
|
+
self._outgoing_middleware.use_sync(wrapper)
|
|
123
|
+
|
|
124
|
+
async def has_channel(self, name: str) -> bool:
|
|
125
|
+
async with self._lock:
|
|
126
|
+
return name in self._channels
|
|
127
|
+
|
|
128
|
+
async def get_channel(self, name: str) -> Channel | None:
|
|
129
|
+
async with self._lock:
|
|
130
|
+
return self._channels.get(name)
|
|
131
|
+
|
|
132
|
+
async def get_or_create_channel(self, name: str) -> Channel:
|
|
133
|
+
async with self._lock:
|
|
134
|
+
existing = self._channels.get(name)
|
|
135
|
+
if existing is not None:
|
|
136
|
+
return existing
|
|
137
|
+
|
|
138
|
+
candidate = self._build_channel(name)
|
|
139
|
+
|
|
140
|
+
async with self._lock:
|
|
141
|
+
existing = self._channels.get(name)
|
|
142
|
+
if existing is not None:
|
|
143
|
+
await candidate.close()
|
|
144
|
+
return existing
|
|
145
|
+
self._channels[name] = candidate
|
|
146
|
+
|
|
147
|
+
try:
|
|
148
|
+
await candidate.start()
|
|
149
|
+
except Exception:
|
|
150
|
+
async with self._lock:
|
|
151
|
+
if self._channels.get(name) is candidate:
|
|
152
|
+
self._channels.pop(name, None)
|
|
153
|
+
raise
|
|
154
|
+
return candidate
|
|
155
|
+
|
|
156
|
+
def _build_channel(self, name: str) -> Channel:
|
|
157
|
+
async def on_destroy() -> None:
|
|
158
|
+
async with self._lock:
|
|
159
|
+
self._channels.pop(name, None)
|
|
160
|
+
|
|
161
|
+
opts = ChannelOptions(
|
|
162
|
+
name=name,
|
|
163
|
+
options=self._options,
|
|
164
|
+
message_middleware=self._message_middleware,
|
|
165
|
+
outgoing_middleware=self._outgoing_middleware,
|
|
166
|
+
leave_handler=self._leave_handler,
|
|
167
|
+
leave_middlewares=self._leave_middlewares,
|
|
168
|
+
on_destroy=on_destroy,
|
|
169
|
+
endpoint_path=self._endpoint_path,
|
|
170
|
+
pubsub=self._pubsub,
|
|
171
|
+
)
|
|
172
|
+
return Channel(opts)
|
|
173
|
+
|
|
174
|
+
async def list_channels(self) -> list[Channel]:
|
|
175
|
+
async with self._lock:
|
|
176
|
+
return list(self._channels.values())
|
|
177
|
+
|
|
178
|
+
async def close(self) -> None:
|
|
179
|
+
async with self._lock:
|
|
180
|
+
channels = list(self._channels.values())
|
|
181
|
+
self._channels.clear()
|
|
182
|
+
for ch in channels:
|
|
183
|
+
await ch.close()
|
pondsocket/middleware.py
ADDED
|
@@ -0,0 +1,100 @@
|
|
|
1
|
+
from __future__ import annotations
|
|
2
|
+
|
|
3
|
+
import asyncio
|
|
4
|
+
from collections.abc import Awaitable, Callable
|
|
5
|
+
from typing import Generic, TypeAlias, TypeVar
|
|
6
|
+
|
|
7
|
+
from .errors import PondError, wrap
|
|
8
|
+
|
|
9
|
+
Request = TypeVar("Request")
|
|
10
|
+
Response = TypeVar("Response")
|
|
11
|
+
|
|
12
|
+
NextFn: TypeAlias = Callable[[], Awaitable[None]]
|
|
13
|
+
HandlerFunc: TypeAlias = Callable[[Request, Response, NextFn], Awaitable[None]]
|
|
14
|
+
FinalHandlerFunc: TypeAlias = Callable[[Request, Response], Awaitable[None]]
|
|
15
|
+
|
|
16
|
+
|
|
17
|
+
class Middleware(Generic[Request, Response]):
|
|
18
|
+
__slots__ = ("_handlers", "_lock")
|
|
19
|
+
|
|
20
|
+
def __init__(self) -> None:
|
|
21
|
+
self._handlers: list[HandlerFunc[Request, Response]] = []
|
|
22
|
+
self._lock = asyncio.Lock()
|
|
23
|
+
|
|
24
|
+
async def use(self, *handlers: HandlerFunc[Request, Response]) -> None:
|
|
25
|
+
async with self._lock:
|
|
26
|
+
self._handlers.extend(handlers)
|
|
27
|
+
|
|
28
|
+
def use_sync(self, *handlers: HandlerFunc[Request, Response]) -> None:
|
|
29
|
+
self._handlers.extend(handlers)
|
|
30
|
+
|
|
31
|
+
async def compose(
|
|
32
|
+
self, *others: Middleware[Request, Response]
|
|
33
|
+
) -> Middleware[Request, Response]:
|
|
34
|
+
result: Middleware[Request, Response] = Middleware()
|
|
35
|
+
async with self._lock:
|
|
36
|
+
result._handlers.extend(self._handlers)
|
|
37
|
+
for other in others:
|
|
38
|
+
async with other._lock:
|
|
39
|
+
result._handlers.extend(other._handlers)
|
|
40
|
+
return result
|
|
41
|
+
|
|
42
|
+
async def handle(
|
|
43
|
+
self,
|
|
44
|
+
request: Request,
|
|
45
|
+
response: Response,
|
|
46
|
+
final: FinalHandlerFunc[Request, Response],
|
|
47
|
+
) -> None:
|
|
48
|
+
async with self._lock:
|
|
49
|
+
handlers = list(self._handlers)
|
|
50
|
+
|
|
51
|
+
if not handlers:
|
|
52
|
+
await final(request, response)
|
|
53
|
+
return
|
|
54
|
+
|
|
55
|
+
async def run(index: int) -> None:
|
|
56
|
+
if index >= len(handlers):
|
|
57
|
+
await final(request, response)
|
|
58
|
+
return
|
|
59
|
+
|
|
60
|
+
async def next_fn() -> None:
|
|
61
|
+
await run(index + 1)
|
|
62
|
+
|
|
63
|
+
await handlers[index](request, response, next_fn)
|
|
64
|
+
|
|
65
|
+
await run(0)
|
|
66
|
+
|
|
67
|
+
def __len__(self) -> int:
|
|
68
|
+
return len(self._handlers)
|
|
69
|
+
|
|
70
|
+
|
|
71
|
+
C = TypeVar("C")
|
|
72
|
+
PerHandlerMiddleware: TypeAlias = Callable[[C, NextFn], Awaitable[None]]
|
|
73
|
+
|
|
74
|
+
|
|
75
|
+
async def execute_with_middleware(
|
|
76
|
+
ctx: C,
|
|
77
|
+
handler: Callable[[C], Awaitable[None]],
|
|
78
|
+
middlewares: list[PerHandlerMiddleware[C]],
|
|
79
|
+
) -> None:
|
|
80
|
+
if not middlewares:
|
|
81
|
+
await handler(ctx)
|
|
82
|
+
return
|
|
83
|
+
|
|
84
|
+
async def run(index: int) -> None:
|
|
85
|
+
if index >= len(middlewares):
|
|
86
|
+
await handler(ctx)
|
|
87
|
+
return
|
|
88
|
+
|
|
89
|
+
async def next_fn() -> None:
|
|
90
|
+
await run(index + 1)
|
|
91
|
+
|
|
92
|
+
await middlewares[index](ctx, next_fn)
|
|
93
|
+
|
|
94
|
+
await run(0)
|
|
95
|
+
|
|
96
|
+
|
|
97
|
+
def wrap_pond_error(err: BaseException, message: str) -> PondError:
|
|
98
|
+
if isinstance(err, PondError):
|
|
99
|
+
return wrap(err, message)
|
|
100
|
+
return wrap(err, message)
|
pondsocket/parser.py
ADDED
|
@@ -0,0 +1,85 @@
|
|
|
1
|
+
from __future__ import annotations
|
|
2
|
+
|
|
3
|
+
from urllib.parse import parse_qs, unquote
|
|
4
|
+
|
|
5
|
+
from .errors import not_found
|
|
6
|
+
from .types import Route
|
|
7
|
+
|
|
8
|
+
|
|
9
|
+
def parse(route: str, current_path: str) -> Route:
|
|
10
|
+
query: dict[str, list[str]] = {}
|
|
11
|
+
params: dict[str, str] = {}
|
|
12
|
+
wildcard: str | None = None
|
|
13
|
+
|
|
14
|
+
if current_path == "":
|
|
15
|
+
current_path = "/"
|
|
16
|
+
|
|
17
|
+
if "?" in current_path:
|
|
18
|
+
path, _, query_string = current_path.partition("?")
|
|
19
|
+
query = parse_qs(query_string, keep_blank_values=True)
|
|
20
|
+
else:
|
|
21
|
+
path = current_path
|
|
22
|
+
|
|
23
|
+
route_segments = _split_path(route)
|
|
24
|
+
path_segments = _split_path(path)
|
|
25
|
+
|
|
26
|
+
wildcard_index = -1
|
|
27
|
+
for i, seg in enumerate(route_segments):
|
|
28
|
+
if seg == "*":
|
|
29
|
+
wildcard_index = i
|
|
30
|
+
break
|
|
31
|
+
|
|
32
|
+
matched = False
|
|
33
|
+
if wildcard_index >= 0:
|
|
34
|
+
if wildcard_index < len(path_segments):
|
|
35
|
+
remaining = "/".join(path_segments[wildcard_index:])
|
|
36
|
+
wildcard = unquote(remaining)
|
|
37
|
+
else:
|
|
38
|
+
wildcard = ""
|
|
39
|
+
route_match = route_segments[:wildcard_index]
|
|
40
|
+
path_match = path_segments[: min(wildcard_index, len(path_segments))]
|
|
41
|
+
matched = _match_segments(route_match, path_match, params)
|
|
42
|
+
else:
|
|
43
|
+
if len(route_segments) == len(path_segments):
|
|
44
|
+
matched = _match_segments(route_segments, path_segments, params)
|
|
45
|
+
|
|
46
|
+
if not matched:
|
|
47
|
+
raise not_found(route, f"route {route} does not match path {current_path}")
|
|
48
|
+
|
|
49
|
+
return Route(params=params, query=query, wildcard=wildcard)
|
|
50
|
+
|
|
51
|
+
|
|
52
|
+
def _match_segments(
|
|
53
|
+
route_segments: list[str],
|
|
54
|
+
path_segments: list[str],
|
|
55
|
+
params: dict[str, str],
|
|
56
|
+
) -> bool:
|
|
57
|
+
if len(route_segments) > len(path_segments):
|
|
58
|
+
return False
|
|
59
|
+
for i, route_seg in enumerate(route_segments):
|
|
60
|
+
if i >= len(path_segments):
|
|
61
|
+
return False
|
|
62
|
+
path_seg = path_segments[i]
|
|
63
|
+
if route_seg.startswith(":"):
|
|
64
|
+
param_name = route_seg[1:]
|
|
65
|
+
params[param_name] = unquote(path_seg)
|
|
66
|
+
continue
|
|
67
|
+
if ":" in route_seg:
|
|
68
|
+
prefix, _, param_name = route_seg.partition(":")
|
|
69
|
+
if not path_seg.startswith(prefix):
|
|
70
|
+
return False
|
|
71
|
+
value = path_seg[len(prefix) :]
|
|
72
|
+
params[param_name] = unquote(value)
|
|
73
|
+
continue
|
|
74
|
+
if route_seg != path_seg:
|
|
75
|
+
return False
|
|
76
|
+
return True
|
|
77
|
+
|
|
78
|
+
|
|
79
|
+
def _split_path(path: str) -> list[str]:
|
|
80
|
+
path = path.strip("/")
|
|
81
|
+
while "//" in path:
|
|
82
|
+
path = path.replace("//", "/")
|
|
83
|
+
if path == "":
|
|
84
|
+
return []
|
|
85
|
+
return path.split("/")
|