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
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
|
%global _empty_manifest_terminate_build 0
Name: python-limitlion
Version: 1.0.0
Release: 1
Summary: Close LimitLion
License: MIT License
URL: http://github.com/closeio/limitlion
Source0: https://mirrors.aliyun.com/pypi/web/packages/bc/f6/ded764d34564965d73cf0d33f17069fc236230706502646b2e744646708e/limitlion-1.0.0.tar.gz
BuildArch: noarch
%description
[](https://circleci.com/gh/closeio/limitlion)
# LimitLion
A token bucket rate limiting throttle using Redis as the backend. Inspired by
Stripe's [Scaling your API with rate limiters](https://stripe.com/blog/rate-limiters)
blog post. Can be used to control processing rates from one to many processes.
Potential implementations include protecting databases from high processing rates,
orchestrating queue consumer processes, or enforcing HTTP request rate limits.
Install with: `pip install limitlion`
Following is a simple example of a throttle named `test` that allows `5` requests per second (RPS) with
a burst factor of `2` using a `8` second window and requesting `1` token (default)
for each unit of work. Look in the `examples` directory for more.
```py
redis = redis.Redis('localhost', 6379)
throttle_configure(redis)
while True:
allowed, tokens, sleep = throttle('test', 5, 2, 8)
if allowed:
print ('Do work here')
else:
print ('Sleeping {}'.format(sleep))
time.sleep(sleep)
```
## Design
The rate limiting logic uses a classic token bucket algorithm but is implemented
entirely as a Lua Redis script. It leverages the Redis [TIME](https://redis.io/commands/time)
command which ensures fair microsecond resolution across all callers independent
of the caller's clock. Note that buckets start and end on whole seconds.
Redis 3.2+ is required because `replicate_commands()` is used to support using
the `TIME` command in a Lua script.
## Configuring
Default values for RPS, burst factor and window size are supplied to the throttle
Lua script. The Lua script creates a `throttle:[throttle name]:knobs` hash with
these values if it does not yet exist in Redis. The script then uses the values
in that `knobs` hash for the token bucket calculations. Each call also sets the
TTL for the `knobs` key to 7 days so it will remain in Redis as long as the
throttle has been active in the last week.
Since these settings are stored in Redis a separate process can be used to adjust
them on the fly. This could simply be manually issuing the Redis command to
change the RPS or a more sophisicated process that polls Prometheus metrics to
determine the current load on your database and adjust the RPS accordingly.
# Running Counter
Another small but useful tool to keep track of counts in Redis for specified
time windows. These counts can then be used to make decisions on limiting or
failing processes as well as for diagnostics. Checkout [`running_counter.py
`](limitlion/running_counter.py) for details.
%package -n python3-limitlion
Summary: Close LimitLion
Provides: python-limitlion
BuildRequires: python3-devel
BuildRequires: python3-setuptools
BuildRequires: python3-pip
%description -n python3-limitlion
[](https://circleci.com/gh/closeio/limitlion)
# LimitLion
A token bucket rate limiting throttle using Redis as the backend. Inspired by
Stripe's [Scaling your API with rate limiters](https://stripe.com/blog/rate-limiters)
blog post. Can be used to control processing rates from one to many processes.
Potential implementations include protecting databases from high processing rates,
orchestrating queue consumer processes, or enforcing HTTP request rate limits.
Install with: `pip install limitlion`
Following is a simple example of a throttle named `test` that allows `5` requests per second (RPS) with
a burst factor of `2` using a `8` second window and requesting `1` token (default)
for each unit of work. Look in the `examples` directory for more.
```py
redis = redis.Redis('localhost', 6379)
throttle_configure(redis)
while True:
allowed, tokens, sleep = throttle('test', 5, 2, 8)
if allowed:
print ('Do work here')
else:
print ('Sleeping {}'.format(sleep))
time.sleep(sleep)
```
## Design
The rate limiting logic uses a classic token bucket algorithm but is implemented
entirely as a Lua Redis script. It leverages the Redis [TIME](https://redis.io/commands/time)
command which ensures fair microsecond resolution across all callers independent
of the caller's clock. Note that buckets start and end on whole seconds.
Redis 3.2+ is required because `replicate_commands()` is used to support using
the `TIME` command in a Lua script.
## Configuring
Default values for RPS, burst factor and window size are supplied to the throttle
Lua script. The Lua script creates a `throttle:[throttle name]:knobs` hash with
these values if it does not yet exist in Redis. The script then uses the values
in that `knobs` hash for the token bucket calculations. Each call also sets the
TTL for the `knobs` key to 7 days so it will remain in Redis as long as the
throttle has been active in the last week.
Since these settings are stored in Redis a separate process can be used to adjust
them on the fly. This could simply be manually issuing the Redis command to
change the RPS or a more sophisicated process that polls Prometheus metrics to
determine the current load on your database and adjust the RPS accordingly.
# Running Counter
Another small but useful tool to keep track of counts in Redis for specified
time windows. These counts can then be used to make decisions on limiting or
failing processes as well as for diagnostics. Checkout [`running_counter.py
`](limitlion/running_counter.py) for details.
%package help
Summary: Development documents and examples for limitlion
Provides: python3-limitlion-doc
%description help
[](https://circleci.com/gh/closeio/limitlion)
# LimitLion
A token bucket rate limiting throttle using Redis as the backend. Inspired by
Stripe's [Scaling your API with rate limiters](https://stripe.com/blog/rate-limiters)
blog post. Can be used to control processing rates from one to many processes.
Potential implementations include protecting databases from high processing rates,
orchestrating queue consumer processes, or enforcing HTTP request rate limits.
Install with: `pip install limitlion`
Following is a simple example of a throttle named `test` that allows `5` requests per second (RPS) with
a burst factor of `2` using a `8` second window and requesting `1` token (default)
for each unit of work. Look in the `examples` directory for more.
```py
redis = redis.Redis('localhost', 6379)
throttle_configure(redis)
while True:
allowed, tokens, sleep = throttle('test', 5, 2, 8)
if allowed:
print ('Do work here')
else:
print ('Sleeping {}'.format(sleep))
time.sleep(sleep)
```
## Design
The rate limiting logic uses a classic token bucket algorithm but is implemented
entirely as a Lua Redis script. It leverages the Redis [TIME](https://redis.io/commands/time)
command which ensures fair microsecond resolution across all callers independent
of the caller's clock. Note that buckets start and end on whole seconds.
Redis 3.2+ is required because `replicate_commands()` is used to support using
the `TIME` command in a Lua script.
## Configuring
Default values for RPS, burst factor and window size are supplied to the throttle
Lua script. The Lua script creates a `throttle:[throttle name]:knobs` hash with
these values if it does not yet exist in Redis. The script then uses the values
in that `knobs` hash for the token bucket calculations. Each call also sets the
TTL for the `knobs` key to 7 days so it will remain in Redis as long as the
throttle has been active in the last week.
Since these settings are stored in Redis a separate process can be used to adjust
them on the fly. This could simply be manually issuing the Redis command to
change the RPS or a more sophisicated process that polls Prometheus metrics to
determine the current load on your database and adjust the RPS accordingly.
# Running Counter
Another small but useful tool to keep track of counts in Redis for specified
time windows. These counts can then be used to make decisions on limiting or
failing processes as well as for diagnostics. Checkout [`running_counter.py
`](limitlion/running_counter.py) for details.
%prep
%autosetup -n limitlion-1.0.0
%build
%py3_build
%install
%py3_install
install -d -m755 %{buildroot}/%{_pkgdocdir}
if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi
if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi
if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi
if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi
pushd %{buildroot}
if [ -d usr/lib ]; then
find usr/lib -type f -printf "\"/%h/%f\"\n" >> filelist.lst
fi
if [ -d usr/lib64 ]; then
find usr/lib64 -type f -printf "\"/%h/%f\"\n" >> filelist.lst
fi
if [ -d usr/bin ]; then
find usr/bin -type f -printf "\"/%h/%f\"\n" >> filelist.lst
fi
if [ -d usr/sbin ]; then
find usr/sbin -type f -printf "\"/%h/%f\"\n" >> filelist.lst
fi
touch doclist.lst
if [ -d usr/share/man ]; then
find usr/share/man -type f -printf "\"/%h/%f.gz\"\n" >> doclist.lst
fi
popd
mv %{buildroot}/filelist.lst .
mv %{buildroot}/doclist.lst .
%files -n python3-limitlion -f filelist.lst
%dir %{python3_sitelib}/*
%files help -f doclist.lst
%{_docdir}/*
%changelog
* Fri Jun 09 2023 Python_Bot <Python_Bot@openeuler.org> - 1.0.0-1
- Package Spec generated
|
