22 | - Matt Robenolt (https://github.com/mattrobenolt)
23 | - Dave Challis (https://github.com/davechallis)
24 | - Florian Bruhin (https://github.com/The-Compiler)
25 | - Brett Randall (https://github.com/javabrett)
26 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | ISC License
2 |
3 | Copyright (c) 2017 Kenneth Reitz.
4 |
5 | Permission to use, copy, modify, and/or distribute this software for any
6 | purpose with or without fee is hereby granted, provided that the above
7 | copyright notice and this permission notice appear in all copies.
8 |
9 | THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10 | WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 | MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12 | ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13 | WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 | ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15 | OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # httpbin(1): HTTP Request & Response Service
2 |
3 |
4 | A [Kenneth Reitz](http://kennethreitz.org/bitcoin) Project.
5 |
6 | 
7 |
8 | Run locally:
9 | ```sh
10 | docker pull kennethreitz/httpbin
11 | docker run -p 80:80 kennethreitz/httpbin
12 | ```
13 |
14 | See http://httpbin.org for more information.
15 |
16 | ## Officially Deployed at:
17 |
18 | - http://httpbin.org
19 | - https://httpbin.org
20 | - https://hub.docker.com/r/kennethreitz/httpbin/
21 |
22 |
23 | ## SEE ALSO
24 |
25 | - http://requestb.in
26 | - http://python-requests.org
27 | - https://grpcb.in/
28 |
29 | ## Build Status
30 |
31 | [](https://travis-ci.org/requests/httpbin)
32 |
--------------------------------------------------------------------------------
/httpbin/structures.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 |
3 | """
4 | httpbin.structures
5 | ~~~~~~~~~~~~~~~~~~~
6 |
7 | Data structures that power httpbin.
8 | """
9 |
10 |
11 | class CaseInsensitiveDict(dict):
12 | """Case-insensitive Dictionary for headers.
13 |
14 | For example, ``headers['content-encoding']`` will return the
15 | value of a ``'Content-Encoding'`` response header.
16 | """
17 |
18 | def _lower_keys(self):
19 | return [k.lower() for k in self.keys()]
20 |
21 | def __contains__(self, key):
22 | return key.lower() in self._lower_keys()
23 |
24 | def __getitem__(self, key):
25 | # We allow fall-through here, so values default to None
26 | if key in self:
27 | return list(self.items())[self._lower_keys().index(key.lower())][1]
28 |
--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
1 | from setuptools import setup, find_packages
2 | import os
3 | import io
4 |
5 |
6 | with open(os.path.join(os.path.realpath(os.path.dirname(__file__)), 'httpbin', 'VERSION')) as version_file:
7 | version = version_file.read().strip()
8 |
9 | setup(
10 | name="httpbin",
11 | version=version,
12 | description="HTTP Request and Response Service",
13 | long_description="A simple HTTP Request & Response Service, written in Python + Flask.",
14 |
15 | # The project URL.
16 | url='https://github.com/requests/httpbin',
17 |
18 | # Author details
19 | author='Kenneth Reitz',
20 | author_email='me@kennethreitz.org',
21 |
22 | # Choose your license
23 | license='MIT',
24 |
25 | classifiers=[
26 | 'Development Status :: 5 - Production/Stable',
27 | 'Intended Audience :: Developers',
28 | 'Natural Language :: English',
29 | 'License :: OSI Approved :: MIT License',
30 | 'Programming Language :: Python',
31 | 'Programming Language :: Python :: 2.7',
32 | 'Programming Language :: Python :: 3.6',
33 | ],
34 | test_suite="test_httpbin",
35 | packages=find_packages(),
36 | include_package_data = True, # include files listed in MANIFEST.in
37 | install_requires=[
38 | 'Flask', 'MarkupSafe', 'decorator', 'itsdangerous', 'six', 'brotlipy',
39 | 'raven[flask]', 'werkzeug>=0.14.1', 'gevent', 'flasgger'
40 | ],
41 | )
42 |
--------------------------------------------------------------------------------
/httpbin/templates/forms-post.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
28 |
29 |
30 |
--------------------------------------------------------------------------------
/httpbin/filters.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 |
3 | """
4 | httpbin.filters
5 | ~~~~~~~~~~~~~~~
6 |
7 | This module provides response filter decorators.
8 | """
9 |
10 | import gzip as gzip2
11 | import zlib
12 |
13 | import brotli as _brotli
14 |
15 | from six import BytesIO
16 | from decimal import Decimal
17 | from time import time as now
18 |
19 | from decorator import decorator
20 | from flask import Flask, Response
21 |
22 |
23 | app = Flask(__name__)
24 |
25 |
26 | @decorator
27 | def x_runtime(f, *args, **kwargs):
28 | """X-Runtime Flask Response Decorator."""
29 |
30 | _t0 = now()
31 | r = f(*args, **kwargs)
32 | _t1 = now()
33 | r.headers['X-Runtime'] = '{0}s'.format(Decimal(str(_t1 - _t0)))
34 |
35 | return r
36 |
37 |
38 | @decorator
39 | def gzip(f, *args, **kwargs):
40 | """GZip Flask Response Decorator."""
41 |
42 | data = f(*args, **kwargs)
43 |
44 | if isinstance(data, Response):
45 | content = data.data
46 | else:
47 | content = data
48 |
49 | gzip_buffer = BytesIO()
50 | gzip_file = gzip2.GzipFile(
51 | mode='wb',
52 | compresslevel=4,
53 | fileobj=gzip_buffer
54 | )
55 | gzip_file.write(content)
56 | gzip_file.close()
57 |
58 | gzip_data = gzip_buffer.getvalue()
59 |
60 | if isinstance(data, Response):
61 | data.data = gzip_data
62 | data.headers['Content-Encoding'] = 'gzip'
63 | data.headers['Content-Length'] = str(len(data.data))
64 |
65 | return data
66 |
67 | return gzip_data
68 |
69 |
70 | @decorator
71 | def deflate(f, *args, **kwargs):
72 | """Deflate Flask Response Decorator."""
73 |
74 | data = f(*args, **kwargs)
75 |
76 | if isinstance(data, Response):
77 | content = data.data
78 | else:
79 | content = data
80 |
81 | deflater = zlib.compressobj()
82 | deflated_data = deflater.compress(content)
83 | deflated_data += deflater.flush()
84 |
85 | if isinstance(data, Response):
86 | data.data = deflated_data
87 | data.headers['Content-Encoding'] = 'deflate'
88 | data.headers['Content-Length'] = str(len(data.data))
89 |
90 | return data
91 |
92 | return deflated_data
93 |
94 |
95 | @decorator
96 | def brotli(f, *args, **kwargs):
97 | """Brotli Flask Response Decorator"""
98 |
99 | data = f(*args, **kwargs)
100 |
101 | if isinstance(data, Response):
102 | content = data.data
103 | else:
104 | content = data
105 |
106 | deflated_data = _brotli.compress(content)
107 |
108 | if isinstance(data, Response):
109 | data.data = deflated_data
110 | data.headers['Content-Encoding'] = 'br'
111 | data.headers['Content-Length'] = str(len(data.data))
112 |
113 | return data
114 |
115 | return deflated_data
116 |
--------------------------------------------------------------------------------
/httpbin/templates/moby.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 | Herman Melville - Moby-Dick
7 |
8 |
9 |
10 | Availing himself of the mild, summer-cool weather that now reigned in these latitudes, and in preparation for the peculiarly active pursuits shortly to be anticipated, Perth, the begrimed, blistered old blacksmith, had not removed his portable forge to the hold again, after concluding his contributory work for Ahab's leg, but still retained it on deck, fast lashed to ringbolts by the foremast; being now almost incessantly invoked by the headsmen, and harpooneers, and bowsmen to do some little job for them; altering, or repairing, or new shaping their various weapons and boat furniture. Often he would be surrounded by an eager circle, all waiting to be served; holding boat-spades, pike-heads, harpoons, and lances, and jealously watching his every sooty movement, as he toiled. Nevertheless, this old man's was a patient hammer wielded by a patient arm. No murmur, no impatience, no petulance did come from him. Silent, slow, and solemn; bowing over still further his chronically broken back, he toiled away, as if toil were life itself, and the heavy beating of his hammer the heavy beating of his heart. And so it was.—Most miserable! A peculiar walk in this old man, a certain slight but painful appearing yawing in his gait, had at an early period of the voyage excited the curiosity of the mariners. And to the importunity of their persisted questionings he had finally given in; and so it came to pass that every one now knew the shameful story of his wretched fate. Belated, and not innocently, one bitter winter's midnight, on the road running between two country towns, the blacksmith half-stupidly felt the deadly numbness stealing over him, and sought refuge in a leaning, dilapidated barn. The issue was, the loss of the extremities of both feet. Out of this revelation, part by part, at last came out the four acts of the gladness, and the one long, and as yet uncatastrophied fifth act of the grief of his life's drama. He was an old man, who, at the age of nearly sixty, had postponedly encountered that thing in sorrow's technicals called ruin. He had been an artisan of famed excellence, and with plenty to do; owned a house and garden; embraced a youthful, daughter-like, loving wife, and three blithe, ruddy children; every Sunday went to a cheerful-looking church, planted in a grove. But one night, under cover of darkness, and further concealed in a most cunning disguisement, a desperate burglar slid into his happy home, and robbed them all of everything. And darker yet to tell, the blacksmith himself did ignorantly conduct this burglar into his family's heart. It was the Bottle Conjuror! Upon the opening of that fatal cork, forth flew the fiend, and shrivelled up his home. Now, for prudent, most wise, and economic reasons, the blacksmith's shop was in the basement of his dwelling, but with a separate entrance to it; so that always had the young and loving healthy wife listened with no unhappy nervousness, but with vigorous pleasure, to the stout ringing of her young-armed old husband's hammer; whose reverberations, muffled by passing through the floors and walls, came up to her, not unsweetly, in her nursery; and so, to stout Labor's iron lullaby, the blacksmith's infants were rocked to slumber. Oh, woe on woe! Oh, Death, why canst thou not sometimes be timely? Hadst thou taken this old blacksmith to thyself ere his full ruin came upon him, then had the young widow had a delicious grief, and her orphans a truly venerable, legendary sire to dream of in their after years; and all of them a care-killing competency.
11 |
12 |
httpbin(1): HTTP Client Testing Service
8 |
211 |
231 |
232 |
233 |
234 |
235 |
237 |
243 |
244 |
245 |
246 |
247 | {% include 'httpbin.1.html' %} {% if tracking_enabled %} {% include 'trackingscripts.html' %} {% endif %}
248 |
249 |
250 |
251 |
252 |
--------------------------------------------------------------------------------
/httpbin/templates/UTF-8-demo.txt:
--------------------------------------------------------------------------------
1 | Unicode Demo
2 |
3 | Taken from http://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-demo.txt
5 |
6 |
7 |
8 | UTF-8 encoded sample plain-text file
9 | ‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
10 |
11 | Markus Kuhn [ˈmaʳkʊs kuːn]
221 |
--------------------------------------------------------------------------------
/httpbin/templates/images/svg_logo.svg:
--------------------------------------------------------------------------------
1 |
2 |
3 | SVG Logo
4 |
5 |
7 |
8 |
35 |
83 |
84 |
85 |
158 |
159 |
160 |
183 | SVG
184 |
257 |
258 |
259 |
260 |
--------------------------------------------------------------------------------
/httpbin/templates/flasgger/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | {{ title }}
7 |
33 |
35 |
41 |
42 |
43 |
44 |
45 |
47 |
48 |
49 |
52 |
53 |
54 |
57 |
58 |
59 |
62 |
63 |
64 |
67 |
68 |
69 |
70 |
72 |
73 |
74 |
76 |
77 |
78 |
79 |
80 |
81 |
122 |
123 |
124 |
125 |
126 |
127 |
128 | [Powered by
129 | Flasgger ]
130 |
132 |
133 |
134 |
2 |
httpbin(1): HTTP Request & Response Service
3 |
Freely hosted in HTTP , HTTPS , & EU flavors by Kenneth Reitz & Heroku .
4 |
5 |
BONUSPOINTS
6 |
7 |
10 |
11 |
ENDPOINTS
12 |
13 |
66 |
67 |
DESCRIPTION
68 |
69 |
Testing an HTTP Library can become difficult sometimes. RequestBin is fantastic for testing POST requests, but doesn't let you control the response. This exists to cover all kinds of HTTP scenarios. Additional endpoints are being considered.
70 |
71 |
All endpoint responses are JSON-encoded.
72 |
73 |
EXAMPLES
74 |
75 |
$ curl http://httpbin.org/ip
76 |
77 |
{"origin": "24.127.96.129"}
78 |
79 |
80 |
$ curl http://httpbin.org/user-agent
81 |
82 |
{"user-agent": "curl/7.19.7 (universal-apple-darwin10.0) libcurl/7.19.7 OpenSSL/0.9.8l zlib/1.2.3"}
83 |
84 |
85 |
$ curl http://httpbin.org/get
86 |
87 |
{
88 | "args": {},
89 | "headers": {
90 | "Accept": "*/*",
91 | "Connection": "close",
92 | "Content-Length": "",
93 | "Content-Type": "",
94 | "Host": "httpbin.org",
95 | "User-Agent": "curl/7.19.7 (universal-apple-darwin10.0) libcurl/7.19.7 OpenSSL/0.9.8l zlib/1.2.3"
96 | },
97 | "origin": "24.127.96.129",
98 | "url": "http://httpbin.org/get"
99 | }
100 |
101 |
102 |
$ curl -I http://httpbin.org/status/418
103 |
104 |
HTTP/1.1 418 I'M A TEAPOT
105 | Server: nginx/0.7.67
106 | Date: Mon, 13 Jun 2011 04:25:38 GMT
107 | Connection: close
108 | x-more-info: http://tools.ietf.org/html/rfc2324
109 | Content-Length: 135
110 |
111 |
112 |
$ curl https://httpbin.org/get?show_env=1
113 |
114 |
{
115 | "headers": {
116 | "Content-Length": "",
117 | "Accept-Language": "en-US,en;q=0.8",
118 | "Accept-Encoding": "gzip,deflate,sdch",
119 | "X-Forwarded-Port": "443",
120 | "X-Forwarded-For": "109.60.101.240",
121 | "Host": "httpbin.org",
122 | "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
123 | "User-Agent": "Mozilla/5.0 (X11; Linux i686) AppleWebKit/535.11 (KHTML, like Gecko) Chrome/17.0.963.83 Safari/535.11",
124 | "X-Request-Start": "1350053933441",
125 | "Accept-Charset": "ISO-8859-1,utf-8;q=0.7,*;q=0.3",
126 | "Connection": "keep-alive",
127 | "X-Forwarded-Proto": "https",
128 | "Cookie": "_gauges_unique_day=1; _gauges_unique_month=1; _gauges_unique_year=1; _gauges_unique=1; _gauges_unique_hour=1",
129 | "Content-Type": ""
130 | },
131 | "args": {
132 | "show_env": "1"
133 | },
134 | "origin": "109.60.101.240",
135 | "url": "http://httpbin.org/get?show_env=1"
136 | }
137 |
138 |
139 |
Installing and running from PyPI
140 |
141 |
You can install httpbin as a library from PyPI and run it as a WSGI app. For example, using Gunicorn:
142 |
143 |
$ pip install httpbin
144 | $ gunicorn httpbin:app
145 |
146 |
147 |
148 |
AUTHOR
149 |
150 |
A Kenneth Reitz project.
151 |
BTC: 1Me2iXTJ91FYZhrGvaGaRDCBtnZ4KdxCug
152 |
153 |
SEE ALSO
154 |
155 |
Hurl.it - Make HTTP requests.
156 |
RequestBin - Inspect HTTP requests.
157 |
http://python-requests.org
158 |
159 |
Run locally: $ docker run -p 80:80 kennethreitz/httpbin"
100 | ),
101 | "contact": {
102 | "responsibleOrganization": "Kenneth Reitz",
103 | "responsibleDeveloper": "Kenneth Reitz",
104 | "email": "me@kennethreitz.org",
105 | "url": "https://kennethreitz.org",
106 | },
107 | # "termsOfService": "http://me.com/terms",
108 | "version": version,
109 | },
110 | "host": "httpbin.org", # overrides localhost:5000
111 | "basePath": "/", # base bash for blueprint registration
112 | "schemes": ["https"],
113 | "protocol": "https",
114 | "tags": [
115 | {
116 | "name": "HTTP Methods",
117 | "description": "Testing different HTTP verbs",
118 | # 'externalDocs': {'description': 'Learn more', 'url': 'https://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html'}
119 | },
120 | {"name": "Auth", "description": "Auth methods"},
121 | {
122 | "name": "Status codes",
123 | "description": "Generates responses with given status code",
124 | },
125 | {"name": "Request inspection", "description": "Inspect the request data"},
126 | {
127 | "name": "Response inspection",
128 | "description": "Inspect the response data like caching and headers",
129 | },
130 | {
131 | "name": "Response formats",
132 | "description": "Returns responses in different data formats",
133 | },
134 | {"name": "Dynamic data", "description": "Generates random and dynamic data"},
135 | {"name": "Cookies", "description": "Creates, reads and deletes Cookies"},
136 | {"name": "Images", "description": "Returns different image formats"},
137 | {"name": "Redirects", "description": "Returns different redirect responses"},
138 | {
139 | "name": "Anything",
140 | "description": "Returns anything that is passed to request",
141 | },
142 | ],
143 | }
144 |
145 | swagger_config = {
146 | "headers": [],
147 | "specs": [
148 | {
149 | "endpoint": "spec",
150 | "route": "/spec.json",
151 | "rule_filter": lambda rule: True, # all in
152 | "model_filter": lambda tag: True, # all in
153 | }
154 | ],
155 | "static_url_path": "/flasgger_static",
156 | # "static_folder": "static", # must be set by user
157 | "swagger_ui": True,
158 | "specs_route": "/",
159 | }
160 |
161 | swagger = Swagger(app, sanitizer=NO_SANITIZER, template=template, config=swagger_config)
162 |
163 | # Set up Bugsnag exception tracking, if desired. To use Bugsnag, install the
164 | # Bugsnag Python client with the command "pip install bugsnag", and set the
165 | # environment variable BUGSNAG_API_KEY. You can also optionally set
166 | # BUGSNAG_RELEASE_STAGE.
167 | if os.environ.get("BUGSNAG_API_KEY") is not None:
168 | try:
169 | import bugsnag
170 | import bugsnag.flask
171 |
172 | release_stage = os.environ.get("BUGSNAG_RELEASE_STAGE") or "production"
173 | bugsnag.configure(
174 | api_key=os.environ.get("BUGSNAG_API_KEY"),
175 | project_root=os.path.dirname(os.path.abspath(__file__)),
176 | use_ssl=True,
177 | release_stage=release_stage,
178 | ignore_classes=["werkzeug.exceptions.NotFound"],
179 | )
180 | bugsnag.flask.handle_exceptions(app)
181 | except:
182 | app.logger.warning("Unable to initialize Bugsnag exception handling.")
183 |
184 | # -----------
185 | # Middlewares
186 | # -----------
187 | """
188 | https://github.com/kennethreitz/httpbin/issues/340
189 | Adds a middleware to provide chunked request encoding support running under
190 | gunicorn only.
191 | Werkzeug required environ 'wsgi.input_terminated' to be set otherwise it
192 | empties the input request stream.
193 | - gunicorn seems to support input_terminated but does not add the environ,
194 | so we add it here.
195 | - flask will hang and does not seem to properly terminate the request, so
196 | we explicitly deny chunked requests.
197 | """
198 |
199 |
200 | @app.before_request
201 | def before_request():
202 | if request.environ.get("HTTP_TRANSFER_ENCODING", "").lower() == "chunked":
203 | server = request.environ.get("SERVER_SOFTWARE", "")
204 | if server.lower().startswith("gunicorn/"):
205 | if "wsgi.input_terminated" in request.environ:
206 | app.logger.debug(
207 | "environ wsgi.input_terminated already set, keeping: %s"
208 | % request.environ["wsgi.input_terminated"]
209 | )
210 | else:
211 | request.environ["wsgi.input_terminated"] = 1
212 | else:
213 | abort(501, "Chunked requests are not supported for server %s" % server)
214 |
215 |
216 | @app.after_request
217 | def set_cors_headers(response):
218 | response.headers["Access-Control-Allow-Origin"] = request.headers.get("Origin", "*")
219 | response.headers["Access-Control-Allow-Credentials"] = "true"
220 |
221 | if request.method == "OPTIONS":
222 | # Both of these headers are only used for the "preflight request"
223 | # http://www.w3.org/TR/cors/#access-control-allow-methods-response-header
224 | response.headers[
225 | "Access-Control-Allow-Methods"
226 | ] = "GET, POST, PUT, DELETE, PATCH, OPTIONS"
227 | response.headers["Access-Control-Max-Age"] = "3600" # 1 hour cache
228 | if request.headers.get("Access-Control-Request-Headers") is not None:
229 | response.headers["Access-Control-Allow-Headers"] = request.headers[
230 | "Access-Control-Request-Headers"
231 | ]
232 | return response
233 |
234 |
235 | # ------
236 | # Routes
237 | # ------
238 |
239 |
240 | @app.route("/legacy")
241 | def view_landing_page():
242 | """Generates Landing Page in legacy layout."""
243 | return render_template("index.html")
244 |
245 |
246 | @app.route("/html")
247 | def view_html_page():
248 | """Returns a simple HTML document.
249 | ---
250 | tags:
251 | - Response formats
252 | produces:
253 | - text/html
254 | responses:
255 | 200:
256 | description: An HTML page.
257 | """
258 |
259 | return render_template("moby.html")
260 |
261 |
262 | @app.route("/robots.txt")
263 | def view_robots_page():
264 | """Returns some robots.txt rules.
265 | ---
266 | tags:
267 | - Response formats
268 | produces:
269 | - text/plain
270 | responses:
271 | 200:
272 | description: Robots file
273 | """
274 |
275 | response = make_response()
276 | response.data = ROBOT_TXT
277 | response.content_type = "text/plain"
278 | return response
279 |
280 |
281 | @app.route("/deny")
282 | def view_deny_page():
283 | """Returns page denied by robots.txt rules.
284 | ---
285 | tags:
286 | - Response formats
287 | produces:
288 | - text/plain
289 | responses:
290 | 200:
291 | description: Denied message
292 | """
293 | response = make_response()
294 | response.data = ANGRY_ASCII
295 | response.content_type = "text/plain"
296 | return response
297 | # return "YOU SHOULDN'T BE HERE"
298 |
299 |
300 | @app.route("/ip")
301 | def view_origin():
302 | """Returns the requester's IP Address.
303 | ---
304 | tags:
305 | - Request inspection
306 | produces:
307 | - application/json
308 | responses:
309 | 200:
310 | description: The Requester's IP Address.
311 | """
312 |
313 | return jsonify(origin=request.headers.get("X-Forwarded-For", request.remote_addr))
314 |
315 |
316 | @app.route("/uuid")
317 | def view_uuid():
318 | """Return a UUID4.
319 | ---
320 | tags:
321 | - Dynamic data
322 | produces:
323 | - application/json
324 | responses:
325 | 200:
326 | description: A UUID4.
327 | """
328 |
329 | return jsonify(uuid=str(uuid.uuid4()))
330 |
331 |
332 | @app.route("/headers")
333 | def view_headers():
334 | """Return the incoming request's HTTP headers.
335 | ---
336 | tags:
337 | - Request inspection
338 | produces:
339 | - application/json
340 | responses:
341 | 200:
342 | description: The request's headers.
343 | """
344 |
345 | return jsonify(get_dict('headers'))
346 |
347 |
348 | @app.route("/user-agent")
349 | def view_user_agent():
350 | """Return the incoming requests's User-Agent header.
351 | ---
352 | tags:
353 | - Request inspection
354 | produces:
355 | - application/json
356 | responses:
357 | 200:
358 | description: The request's User-Agent header.
359 | """
360 |
361 | headers = get_headers()
362 |
363 | return jsonify({"user-agent": headers["user-agent"]})
364 |
365 |
366 | @app.route("/get", methods=("GET",))
367 | def view_get():
368 | """The request's query parameters.
369 | ---
370 | tags:
371 | - HTTP Methods
372 | produces:
373 | - application/json
374 | responses:
375 | 200:
376 | description: The request's query parameters.
377 | """
378 |
379 | return jsonify(get_dict("url", "args", "headers", "origin"))
380 |
381 |
382 | @app.route("/anything", methods=["GET", "POST", "PUT", "DELETE", "PATCH", "TRACE"])
383 | @app.route(
384 | "/anything/",
385 | methods=["GET", "POST", "PUT", "DELETE", "PATCH", "TRACE"],
386 | )
387 | def view_anything(anything=None):
388 | """Returns anything passed in request data.
389 | ---
390 | tags:
391 | - Anything
392 | produces:
393 | - application/json
394 | responses:
395 | 200:
396 | description: Anything passed in request
397 | """
398 |
399 | return jsonify(
400 | get_dict(
401 | "url",
402 | "args",
403 | "headers",
404 | "origin",
405 | "method",
406 | "form",
407 | "data",
408 | "files",
409 | "json",
410 | )
411 | )
412 |
413 |
414 | @app.route("/post", methods=("POST",))
415 | def view_post():
416 | """The request's POST parameters.
417 | ---
418 | tags:
419 | - HTTP Methods
420 | produces:
421 | - application/json
422 | responses:
423 | 200:
424 | description: The request's POST parameters.
425 | """
426 |
427 | return jsonify(
428 | get_dict("url", "args", "form", "data", "origin", "headers", "files", "json")
429 | )
430 |
431 |
432 | @app.route("/put", methods=("PUT",))
433 | def view_put():
434 | """The request's PUT parameters.
435 | ---
436 | tags:
437 | - HTTP Methods
438 | produces:
439 | - application/json
440 | responses:
441 | 200:
442 | description: The request's PUT parameters.
443 | """
444 |
445 | return jsonify(
446 | get_dict("url", "args", "form", "data", "origin", "headers", "files", "json")
447 | )
448 |
449 |
450 | @app.route("/patch", methods=("PATCH",))
451 | def view_patch():
452 | """The request's PATCH parameters.
453 | ---
454 | tags:
455 | - HTTP Methods
456 | produces:
457 | - application/json
458 | responses:
459 | 200:
460 | description: The request's PATCH parameters.
461 | """
462 |
463 | return jsonify(
464 | get_dict("url", "args", "form", "data", "origin", "headers", "files", "json")
465 | )
466 |
467 |
468 | @app.route("/delete", methods=("DELETE",))
469 | def view_delete():
470 | """The request's DELETE parameters.
471 | ---
472 | tags:
473 | - HTTP Methods
474 | produces:
475 | - application/json
476 | responses:
477 | 200:
478 | description: The request's DELETE parameters.
479 | """
480 |
481 | return jsonify(
482 | get_dict("url", "args", "form", "data", "origin", "headers", "files", "json")
483 | )
484 |
485 |
486 | @app.route("/gzip")
487 | @filters.gzip
488 | def view_gzip_encoded_content():
489 | """Returns GZip-encoded data.
490 | ---
491 | tags:
492 | - Response formats
493 | produces:
494 | - application/json
495 | responses:
496 | 200:
497 | description: GZip-encoded data.
498 | """
499 |
500 | return jsonify(get_dict("origin", "headers", method=request.method, gzipped=True))
501 |
502 |
503 | @app.route("/deflate")
504 | @filters.deflate
505 | def view_deflate_encoded_content():
506 | """Returns Deflate-encoded data.
507 | ---
508 | tags:
509 | - Response formats
510 | produces:
511 | - application/json
512 | responses:
513 | 200:
514 | description: Defalte-encoded data.
515 | """
516 |
517 | return jsonify(get_dict("origin", "headers", method=request.method, deflated=True))
518 |
519 |
520 | @app.route("/brotli")
521 | @filters.brotli
522 | def view_brotli_encoded_content():
523 | """Returns Brotli-encoded data.
524 | ---
525 | tags:
526 | - Response formats
527 | produces:
528 | - application/json
529 | responses:
530 | 200:
531 | description: Brotli-encoded data.
532 | """
533 |
534 | return jsonify(get_dict("origin", "headers", method=request.method, brotli=True))
535 |
536 |
537 | @app.route("/redirect/")
538 | def redirect_n_times(n):
539 | """302 Redirects n times.
540 | ---
541 | tags:
542 | - Redirects
543 | parameters:
544 | - in: path
545 | name: n
546 | type: int
547 | produces:
548 | - text/html
549 | responses:
550 | 302:
551 | description: A redirection.
552 | """
553 | assert n > 0
554 |
555 | absolute = request.args.get("absolute", "false").lower() == "true"
556 |
557 | if n == 1:
558 | return redirect(url_for("view_get", _external=absolute))
559 |
560 | if absolute:
561 | return _redirect("absolute", n, True)
562 | else:
563 | return _redirect("relative", n, False)
564 |
565 |
566 | def _redirect(kind, n, external):
567 | return redirect(
568 | url_for("{0}_redirect_n_times".format(kind), n=n - 1, _external=external)
569 | )
570 |
571 |
572 | @app.route("/redirect-to", methods=["GET", "POST", "PUT", "DELETE", "PATCH", "TRACE"])
573 | def redirect_to():
574 | """302/3XX Redirects to the given URL.
575 | ---
576 | tags:
577 | - Redirects
578 | produces:
579 | - text/html
580 | get:
581 | parameters:
582 | - in: query
583 | name: url
584 | type: string
585 | required: true
586 | - in: query
587 | name: status_code
588 | type: int
589 | post:
590 | consumes:
591 | - application/x-www-form-urlencoded
592 | parameters:
593 | - in: formData
594 | name: url
595 | type: string
596 | required: true
597 | - in: formData
598 | name: status_code
599 | type: int
600 | required: false
601 | patch:
602 | consumes:
603 | - application/x-www-form-urlencoded
604 | parameters:
605 | - in: formData
606 | name: url
607 | type: string
608 | required: true
609 | - in: formData
610 | name: status_code
611 | type: int
612 | required: false
613 | put:
614 | consumes:
615 | - application/x-www-form-urlencoded
616 | parameters:
617 | - in: formData
618 | name: url
619 | type: string
620 | required: true
621 | - in: formData
622 | name: status_code
623 | type: int
624 | required: false
625 | responses:
626 | 302:
627 | description: A redirection.
628 | """
629 |
630 | args_dict = request.args.items()
631 | args = CaseInsensitiveDict(args_dict)
632 |
633 | # We need to build the response manually and convert to UTF-8 to prevent
634 | # werkzeug from "fixing" the URL. This endpoint should set the Location
635 | # header to the exact string supplied.
636 | response = app.make_response("")
637 | response.status_code = 302
638 | if "status_code" in args:
639 | status_code = int(args["status_code"])
640 | if status_code >= 300 and status_code < 400:
641 | response.status_code = status_code
642 | response.headers["Location"] = args["url"].encode("utf-8")
643 |
644 | return response
645 |
646 |
647 | @app.route("/relative-redirect/")
648 | def relative_redirect_n_times(n):
649 | """Relatively 302 Redirects n times.
650 | ---
651 | tags:
652 | - Redirects
653 | parameters:
654 | - in: path
655 | name: n
656 | type: int
657 | produces:
658 | - text/html
659 | responses:
660 | 302:
661 | description: A redirection.
662 | """
663 |
664 | assert n > 0
665 |
666 | response = app.make_response("")
667 | response.status_code = 302
668 |
669 | if n == 1:
670 | response.headers["Location"] = url_for("view_get")
671 | return response
672 |
673 | response.headers["Location"] = url_for("relative_redirect_n_times", n=n - 1)
674 | return response
675 |
676 |
677 | @app.route("/absolute-redirect/")
678 | def absolute_redirect_n_times(n):
679 | """Absolutely 302 Redirects n times.
680 | ---
681 | tags:
682 | - Redirects
683 | parameters:
684 | - in: path
685 | name: n
686 | type: int
687 | produces:
688 | - text/html
689 | responses:
690 | 302:
691 | description: A redirection.
692 | """
693 |
694 | assert n > 0
695 |
696 | if n == 1:
697 | return redirect(url_for("view_get", _external=True))
698 |
699 | return _redirect("absolute", n, True)
700 |
701 |
702 | @app.route("/stream/")
703 | def stream_n_messages(n):
704 | """Stream n JSON responses
705 | ---
706 | tags:
707 | - Dynamic data
708 | parameters:
709 | - in: path
710 | name: n
711 | type: int
712 | produces:
713 | - application/json
714 | responses:
715 | 200:
716 | description: Streamed JSON responses.
717 | """
718 | response = get_dict("url", "args", "headers", "origin")
719 | n = min(n, 100)
720 |
721 | def generate_stream():
722 | for i in range(n):
723 | response["id"] = i
724 | yield json.dumps(response) + "\n"
725 |
726 | return Response(generate_stream(), headers={"Content-Type": "application/json"})
727 |
728 |
729 | @app.route(
730 | "/status/", methods=["GET", "POST", "PUT", "DELETE", "PATCH", "TRACE"]
731 | )
732 | def view_status_code(codes):
733 | """Return status code or random status code if more than one are given
734 | ---
735 | tags:
736 | - Status codes
737 | parameters:
738 | - in: path
739 | name: codes
740 | produces:
741 | - text/plain
742 | responses:
743 | 100:
744 | description: Informational responses
745 | 200:
746 | description: Success
747 | 300:
748 | description: Redirection
749 | 400:
750 | description: Client Errors
751 | 500:
752 | description: Server Errors
753 | """
754 |
755 | if "," not in codes:
756 | try:
757 | code = int(codes)
758 | except ValueError:
759 | return Response("Invalid status code", status=400)
760 | return status_code(code)
761 |
762 | choices = []
763 | for choice in codes.split(","):
764 | if ":" not in choice:
765 | code = choice
766 | weight = 1
767 | else:
768 | code, weight = choice.split(":")
769 |
770 | try:
771 | choices.append((int(code), float(weight)))
772 | except ValueError:
773 | return Response("Invalid status code", status=400)
774 |
775 | code = weighted_choice(choices)
776 |
777 | return status_code(code)
778 |
779 |
780 | @app.route("/response-headers", methods=["GET", "POST"])
781 | def response_headers():
782 | """Returns a set of response headers from the query string.
783 | ---
784 | tags:
785 | - Response inspection
786 | parameters:
787 | - in: query
788 | name: freeform
789 | explode: true
790 | allowEmptyValue: true
791 | schema:
792 | type: object
793 | additionalProperties:
794 | type: string
795 | style: form
796 | produces:
797 | - application/json
798 | responses:
799 | 200:
800 | description: Response headers
801 | """
802 | # Pending swaggerUI update
803 | # https://github.com/swagger-api/swagger-ui/issues/3850
804 | headers = MultiDict(request.args.items(multi=True))
805 | response = jsonify(list(headers.lists()))
806 |
807 | while True:
808 | original_data = response.data
809 | d = {}
810 | for key in response.headers.keys():
811 | value = response.headers.get_all(key)
812 | if len(value) == 1:
813 | value = value[0]
814 | d[key] = value
815 | response = jsonify(d)
816 | for key, value in headers.items(multi=True):
817 | response.headers.add(key, value)
818 | response_has_changed = response.data != original_data
819 | if not response_has_changed:
820 | break
821 | return response
822 |
823 |
824 | @app.route("/cookies")
825 | def view_cookies(hide_env=True):
826 | """Returns cookie data.
827 | ---
828 | tags:
829 | - Cookies
830 | produces:
831 | - application/json
832 | responses:
833 | 200:
834 | description: Set cookies.
835 | """
836 |
837 | cookies = dict(request.cookies.items())
838 |
839 | if hide_env and ("show_env" not in request.args):
840 | for key in ENV_COOKIES:
841 | try:
842 | del cookies[key]
843 | except KeyError:
844 | pass
845 |
846 | return jsonify(cookies=cookies)
847 |
848 |
849 | @app.route("/forms/post")
850 | def view_forms_post():
851 | """Simple HTML form."""
852 |
853 | return render_template("forms-post.html")
854 |
855 |
856 | @app.route("/cookies/set//")
857 | def set_cookie(name, value):
858 | """Sets a cookie and redirects to cookie list.
859 | ---
860 | tags:
861 | - Cookies
862 | parameters:
863 | - in: path
864 | name: name
865 | type: string
866 | - in: path
867 | name: value
868 | type: string
869 | produces:
870 | - text/plain
871 | responses:
872 | 200:
873 | description: Set cookies and redirects to cookie list.
874 | """
875 |
876 | r = app.make_response(redirect(url_for("view_cookies")))
877 | r.set_cookie(key=name, value=value, secure=secure_cookie())
878 |
879 | return r
880 |
881 |
882 | @app.route("/cookies/set")
883 | def set_cookies():
884 | """Sets cookie(s) as provided by the query string and redirects to cookie list.
885 | ---
886 | tags:
887 | - Cookies
888 | parameters:
889 | - in: query
890 | name: freeform
891 | explode: true
892 | allowEmptyValue: true
893 | schema:
894 | type: object
895 | additionalProperties:
896 | type: string
897 | style: form
898 | produces:
899 | - text/plain
900 | responses:
901 | 200:
902 | description: Redirect to cookie list
903 | """
904 |
905 | cookies = dict(request.args.items())
906 | r = app.make_response(redirect(url_for("view_cookies")))
907 | for key, value in cookies.items():
908 | r.set_cookie(key=key, value=value, secure=secure_cookie())
909 |
910 | return r
911 |
912 |
913 | @app.route("/cookies/delete")
914 | def delete_cookies():
915 | """Deletes cookie(s) as provided by the query string and redirects to cookie list.
916 | ---
917 | tags:
918 | - Cookies
919 | parameters:
920 | - in: query
921 | name: freeform
922 | explode: true
923 | allowEmptyValue: true
924 | schema:
925 | type: object
926 | additionalProperties:
927 | type: string
928 | style: form
929 | produces:
930 | - text/plain
931 | responses:
932 | 200:
933 | description: Redirect to cookie list
934 | """
935 |
936 | cookies = dict(request.args.items())
937 | r = app.make_response(redirect(url_for("view_cookies")))
938 | for key, value in cookies.items():
939 | r.delete_cookie(key=key)
940 |
941 | return r
942 |
943 |
944 | @app.route("/basic-auth//")
945 | def basic_auth(user="user", passwd="passwd"):
946 | """Prompts the user for authorization using HTTP Basic Auth.
947 | ---
948 | tags:
949 | - Auth
950 | parameters:
951 | - in: path
952 | name: user
953 | type: string
954 | - in: path
955 | name: passwd
956 | type: string
957 | produces:
958 | - application/json
959 | responses:
960 | 200:
961 | description: Sucessful authentication.
962 | 401:
963 | description: Unsuccessful authentication.
964 | """
965 |
966 | if not check_basic_auth(user, passwd):
967 | return status_code(401)
968 |
969 | return jsonify(authenticated=True, user=user)
970 |
971 |
972 | @app.route("/hidden-basic-auth//")
973 | def hidden_basic_auth(user="user", passwd="passwd"):
974 | """Prompts the user for authorization using HTTP Basic Auth.
975 | ---
976 | tags:
977 | - Auth
978 | parameters:
979 | - in: path
980 | name: user
981 | type: string
982 | - in: path
983 | name: passwd
984 | type: string
985 | produces:
986 | - application/json
987 | responses:
988 | 200:
989 | description: Sucessful authentication.
990 | 404:
991 | description: Unsuccessful authentication.
992 | """
993 |
994 | if not check_basic_auth(user, passwd):
995 | return status_code(404)
996 | return jsonify(authenticated=True, user=user)
997 |
998 |
999 | @app.route("/bearer")
1000 | def bearer_auth():
1001 | """Prompts the user for authorization using bearer authentication.
1002 | ---
1003 | tags:
1004 | - Auth
1005 | parameters:
1006 | - in: header
1007 | name: Authorization
1008 | schema:
1009 | type: string
1010 | produces:
1011 | - application/json
1012 | responses:
1013 | 200:
1014 | description: Sucessful authentication.
1015 | 401:
1016 | description: Unsuccessful authentication.
1017 | """
1018 | authorization = request.headers.get("Authorization")
1019 | if not (authorization and authorization.startswith("Bearer ")):
1020 | response = app.make_response("")
1021 | response.headers["WWW-Authenticate"] = "Bearer"
1022 | response.status_code = 401
1023 | return response
1024 | slice_start = len("Bearer ")
1025 | token = authorization[slice_start:]
1026 |
1027 | return jsonify(authenticated=True, token=token)
1028 |
1029 |
1030 | @app.route("/digest-auth///")
1031 | def digest_auth_md5(qop=None, user="user", passwd="passwd"):
1032 | """Prompts the user for authorization using Digest Auth.
1033 | ---
1034 | tags:
1035 | - Auth
1036 | parameters:
1037 | - in: path
1038 | name: qop
1039 | type: string
1040 | description: auth or auth-int
1041 | - in: path
1042 | name: user
1043 | type: string
1044 | - in: path
1045 | name: passwd
1046 | type: string
1047 | produces:
1048 | - application/json
1049 | responses:
1050 | 200:
1051 | description: Sucessful authentication.
1052 | 401:
1053 | description: Unsuccessful authentication.
1054 | """
1055 | return digest_auth(qop, user, passwd, "MD5", "never")
1056 |
1057 |
1058 | @app.route("/digest-auth////")
1059 | def digest_auth_nostale(qop=None, user="user", passwd="passwd", algorithm="MD5"):
1060 | """Prompts the user for authorization using Digest Auth + Algorithm.
1061 | ---
1062 | tags:
1063 | - Auth
1064 | parameters:
1065 | - in: path
1066 | name: qop
1067 | type: string
1068 | description: auth or auth-int
1069 | - in: path
1070 | name: user
1071 | type: string
1072 | - in: path
1073 | name: passwd
1074 | type: string
1075 | - in: path
1076 | name: algorithm
1077 | type: string
1078 | description: MD5, SHA-256, SHA-512
1079 | default: MD5
1080 | produces:
1081 | - application/json
1082 | responses:
1083 | 200:
1084 | description: Sucessful authentication.
1085 | 401:
1086 | description: Unsuccessful authentication.
1087 | """
1088 | return digest_auth(qop, user, passwd, algorithm, "never")
1089 |
1090 |
1091 | @app.route("/digest-auth/////")
1092 | def digest_auth(
1093 | qop=None, user="user", passwd="passwd", algorithm="MD5", stale_after="never"
1094 | ):
1095 | """Prompts the user for authorization using Digest Auth + Algorithm.
1096 | allow settings the stale_after argument.
1097 | ---
1098 | tags:
1099 | - Auth
1100 | parameters:
1101 | - in: path
1102 | name: qop
1103 | type: string
1104 | description: auth or auth-int
1105 | - in: path
1106 | name: user
1107 | type: string
1108 | - in: path
1109 | name: passwd
1110 | type: string
1111 | - in: path
1112 | name: algorithm
1113 | type: string
1114 | description: MD5, SHA-256, SHA-512
1115 | default: MD5
1116 | - in: path
1117 | name: stale_after
1118 | type: string
1119 | default: never
1120 | produces:
1121 | - application/json
1122 | responses:
1123 | 200:
1124 | description: Sucessful authentication.
1125 | 401:
1126 | description: Unsuccessful authentication.
1127 | """
1128 | require_cookie_handling = request.args.get("require-cookie", "").lower() in (
1129 | "1",
1130 | "t",
1131 | "true",
1132 | )
1133 | if algorithm not in ("MD5", "SHA-256", "SHA-512"):
1134 | algorithm = "MD5"
1135 |
1136 | if qop not in ("auth", "auth-int"):
1137 | qop = None
1138 |
1139 | authorization = request.headers.get("Authorization")
1140 | credentials = None
1141 | if authorization:
1142 | credentials = parse_authorization_header(authorization)
1143 |
1144 | if (
1145 | not authorization
1146 | or not credentials
1147 | or credentials.type.lower() != "digest"
1148 | or (require_cookie_handling and "Cookie" not in request.headers)
1149 | ):
1150 | response = digest_challenge_response(app, qop, algorithm)
1151 | response.set_cookie("stale_after", value=stale_after)
1152 | response.set_cookie("fake", value="fake_value")
1153 | return response
1154 |
1155 | if require_cookie_handling and request.cookies.get("fake") != "fake_value":
1156 | response = jsonify({"errors": ["missing cookie set on challenge"]})
1157 | response.set_cookie("fake", value="fake_value")
1158 | response.status_code = 403
1159 | return response
1160 |
1161 | current_nonce = credentials.get("nonce")
1162 |
1163 | stale_after_value = None
1164 | if "stale_after" in request.cookies:
1165 | stale_after_value = request.cookies.get("stale_after")
1166 |
1167 | if (
1168 | "last_nonce" in request.cookies
1169 | and current_nonce == request.cookies.get("last_nonce")
1170 | or stale_after_value == "0"
1171 | ):
1172 | response = digest_challenge_response(app, qop, algorithm, True)
1173 | response.set_cookie("stale_after", value=stale_after)
1174 | response.set_cookie("last_nonce", value=current_nonce)
1175 | response.set_cookie("fake", value="fake_value")
1176 | return response
1177 |
1178 | if not check_digest_auth(user, passwd):
1179 | response = digest_challenge_response(app, qop, algorithm, False)
1180 | response.set_cookie("stale_after", value=stale_after)
1181 | response.set_cookie("last_nonce", value=current_nonce)
1182 | response.set_cookie("fake", value="fake_value")
1183 | return response
1184 |
1185 | response = jsonify(authenticated=True, user=user)
1186 | response.set_cookie("fake", value="fake_value")
1187 | if stale_after_value:
1188 | response.set_cookie(
1189 | "stale_after", value=next_stale_after_value(stale_after_value)
1190 | )
1191 |
1192 | return response
1193 |
1194 |
1195 | @app.route("/delay/", methods=["GET", "POST", "PUT", "DELETE", "PATCH", "TRACE"])
1196 | def delay_response(delay):
1197 | """Returns a delayed response (max of 10 seconds).
1198 | ---
1199 | tags:
1200 | - Dynamic data
1201 | parameters:
1202 | - in: path
1203 | name: delay
1204 | type: int
1205 | produces:
1206 | - application/json
1207 | responses:
1208 | 200:
1209 | description: A delayed response.
1210 | """
1211 | delay = min(float(delay), 10)
1212 |
1213 | time.sleep(delay)
1214 |
1215 | return jsonify(
1216 | get_dict("url", "args", "form", "data", "origin", "headers", "files")
1217 | )
1218 |
1219 |
1220 | @app.route("/drip")
1221 | def drip():
1222 | """Drips data over a duration after an optional initial delay.
1223 | ---
1224 | tags:
1225 | - Dynamic data
1226 | parameters:
1227 | - in: query
1228 | name: duration
1229 | type: number
1230 | description: The amount of time (in seconds) over which to drip each byte
1231 | default: 2
1232 | required: false
1233 | - in: query
1234 | name: numbytes
1235 | type: integer
1236 | description: The number of bytes to respond with
1237 | default: 10
1238 | required: false
1239 | - in: query
1240 | name: code
1241 | type: integer
1242 | description: The response code that will be returned
1243 | default: 200
1244 | required: false
1245 | - in: query
1246 | name: delay
1247 | type: number
1248 | description: The amount of time (in seconds) to delay before responding
1249 | default: 2
1250 | required: false
1251 | produces:
1252 | - application/octet-stream
1253 | responses:
1254 | 200:
1255 | description: A dripped response.
1256 | """
1257 | args = CaseInsensitiveDict(request.args.items())
1258 | duration = float(args.get("duration", 2))
1259 | numbytes = min(int(args.get("numbytes", 10)), (10 * 1024 * 1024)) # set 10MB limit
1260 | code = int(args.get("code", 200))
1261 |
1262 | if numbytes <= 0:
1263 | response = Response("number of bytes must be positive", status=400)
1264 | return response
1265 |
1266 | delay = float(args.get("delay", 0))
1267 | if delay > 0:
1268 | time.sleep(delay)
1269 |
1270 | pause = duration / numbytes
1271 |
1272 | def generate_bytes():
1273 | for i in xrange(numbytes):
1274 | yield b"*"
1275 | time.sleep(pause)
1276 |
1277 | response = Response(
1278 | generate_bytes(),
1279 | headers={
1280 | "Content-Type": "application/octet-stream",
1281 | "Content-Length": str(numbytes),
1282 | },
1283 | )
1284 |
1285 | response.status_code = code
1286 |
1287 | return response
1288 |
1289 |
1290 | @app.route("/base64/")
1291 | def decode_base64(value):
1292 | """Decodes base64url-encoded string.
1293 | ---
1294 | tags:
1295 | - Dynamic data
1296 | parameters:
1297 | - in: path
1298 | name: value
1299 | type: string
1300 | default: SFRUUEJJTiBpcyBhd2Vzb21l
1301 | produces:
1302 | - text/html
1303 | responses:
1304 | 200:
1305 | description: Decoded base64 content.
1306 | """
1307 | encoded = value.encode("utf-8") # base64 expects binary string as input
1308 | try:
1309 | return base64.urlsafe_b64decode(encoded).decode("utf-8")
1310 | except:
1311 | return "Incorrect Base64 data try: SFRUUEJJTiBpcyBhd2Vzb21l"
1312 |
1313 |
1314 | @app.route("/cache", methods=("GET",))
1315 | def cache():
1316 | """Returns a 304 if an If-Modified-Since header or If-None-Match is present. Returns the same as a GET otherwise.
1317 | ---
1318 | tags:
1319 | - Response inspection
1320 | parameters:
1321 | - in: header
1322 | name: If-Modified-Since
1323 | - in: header
1324 | name: If-None-Match
1325 | produces:
1326 | - application/json
1327 | responses:
1328 | 200:
1329 | description: Cached response
1330 | 304:
1331 | description: Modified
1332 |
1333 | """
1334 | is_conditional = request.headers.get("If-Modified-Since") or request.headers.get(
1335 | "If-None-Match"
1336 | )
1337 |
1338 | if is_conditional is None:
1339 | response = view_get()
1340 | response.headers["Last-Modified"] = http_date()
1341 | response.headers["ETag"] = uuid.uuid4().hex
1342 | return response
1343 | else:
1344 | return status_code(304)
1345 |
1346 |
1347 | @app.route("/etag/", methods=("GET",))
1348 | def etag(etag):
1349 | """Assumes the resource has the given etag and responds to If-None-Match and If-Match headers appropriately.
1350 | ---
1351 | tags:
1352 | - Response inspection
1353 | parameters:
1354 | - in: header
1355 | name: If-None-Match
1356 | - in: header
1357 | name: If-Match
1358 | produces:
1359 | - application/json
1360 | responses:
1361 | 200:
1362 | description: Normal response
1363 | 412:
1364 | description: match
1365 |
1366 | """
1367 | if_none_match = parse_multi_value_header(request.headers.get("If-None-Match"))
1368 | if_match = parse_multi_value_header(request.headers.get("If-Match"))
1369 |
1370 | if if_none_match:
1371 | if etag in if_none_match or "*" in if_none_match:
1372 | response = status_code(304)
1373 | response.headers["ETag"] = etag
1374 | return response
1375 | elif if_match:
1376 | if etag not in if_match and "*" not in if_match:
1377 | return status_code(412)
1378 |
1379 | # Special cases don't apply, return normal response
1380 | response = view_get()
1381 | response.headers["ETag"] = etag
1382 | return response
1383 |
1384 |
1385 | @app.route("/cache/")
1386 | def cache_control(value):
1387 | """Sets a Cache-Control header for n seconds.
1388 | ---
1389 | tags:
1390 | - Response inspection
1391 | parameters:
1392 | - in: path
1393 | name: value
1394 | type: integer
1395 | produces:
1396 | - application/json
1397 | responses:
1398 | 200:
1399 | description: Cache control set
1400 | """
1401 | response = view_get()
1402 | response.headers["Cache-Control"] = "public, max-age={0}".format(value)
1403 | return response
1404 |
1405 |
1406 | @app.route("/encoding/utf8")
1407 | def encoding():
1408 | """Returns a UTF-8 encoded body.
1409 | ---
1410 | tags:
1411 | - Response formats
1412 | produces:
1413 | - text/html
1414 | responses:
1415 | 200:
1416 | description: Encoded UTF-8 content.
1417 | """
1418 |
1419 | return render_template("UTF-8-demo.txt")
1420 |
1421 |
1422 | @app.route("/bytes/")
1423 | def random_bytes(n):
1424 | """Returns n random bytes generated with given seed
1425 | ---
1426 | tags:
1427 | - Dynamic data
1428 | parameters:
1429 | - in: path
1430 | name: n
1431 | type: int
1432 | produces:
1433 | - application/octet-stream
1434 | responses:
1435 | 200:
1436 | description: Bytes.
1437 | """
1438 |
1439 | n = min(n, 100 * 1024) # set 100KB limit
1440 |
1441 | params = CaseInsensitiveDict(request.args.items())
1442 | if "seed" in params:
1443 | random.seed(int(params["seed"]))
1444 |
1445 | response = make_response()
1446 |
1447 | # Note: can't just use os.urandom here because it ignores the seed
1448 | response.data = bytearray(random.randint(0, 255) for i in range(n))
1449 | response.content_type = "application/octet-stream"
1450 | return response
1451 |
1452 |
1453 | @app.route("/stream-bytes/")
1454 | def stream_random_bytes(n):
1455 | """Streams n random bytes generated with given seed, at given chunk size per packet.
1456 | ---
1457 | tags:
1458 | - Dynamic data
1459 | parameters:
1460 | - in: path
1461 | name: n
1462 | type: int
1463 | produces:
1464 | - application/octet-stream
1465 | responses:
1466 | 200:
1467 | description: Bytes.
1468 | """
1469 | n = min(n, 100 * 1024) # set 100KB limit
1470 |
1471 | params = CaseInsensitiveDict(request.args.items())
1472 | if "seed" in params:
1473 | random.seed(int(params["seed"]))
1474 |
1475 | if "chunk_size" in params:
1476 | chunk_size = max(1, int(params["chunk_size"]))
1477 | else:
1478 | chunk_size = 10 * 1024
1479 |
1480 | def generate_bytes():
1481 | chunks = bytearray()
1482 |
1483 | for i in xrange(n):
1484 | chunks.append(random.randint(0, 255))
1485 | if len(chunks) == chunk_size:
1486 | yield (bytes(chunks))
1487 | chunks = bytearray()
1488 |
1489 | if chunks:
1490 | yield (bytes(chunks))
1491 |
1492 | headers = {"Content-Type": "application/octet-stream"}
1493 |
1494 | return Response(generate_bytes(), headers=headers)
1495 |
1496 |
1497 | @app.route("/range/")
1498 | def range_request(numbytes):
1499 | """Streams n random bytes generated with given seed, at given chunk size per packet.
1500 | ---
1501 | tags:
1502 | - Dynamic data
1503 | parameters:
1504 | - in: path
1505 | name: numbytes
1506 | type: int
1507 | produces:
1508 | - application/octet-stream
1509 | responses:
1510 | 200:
1511 | description: Bytes.
1512 | """
1513 |
1514 | if numbytes <= 0 or numbytes > (100 * 1024):
1515 | response = Response(
1516 | headers={"ETag": "range%d" % numbytes, "Accept-Ranges": "bytes"}
1517 | )
1518 | response.status_code = 404
1519 | response.data = "number of bytes must be in the range (0, 102400]"
1520 | return response
1521 |
1522 | params = CaseInsensitiveDict(request.args.items())
1523 | if "chunk_size" in params:
1524 | chunk_size = max(1, int(params["chunk_size"]))
1525 | else:
1526 | chunk_size = 10 * 1024
1527 |
1528 | duration = float(params.get("duration", 0))
1529 | pause_per_byte = duration / numbytes
1530 |
1531 | request_headers = get_headers()
1532 | first_byte_pos, last_byte_pos = get_request_range(request_headers, numbytes)
1533 | range_length = (last_byte_pos + 1) - first_byte_pos
1534 |
1535 | if (
1536 | first_byte_pos > last_byte_pos
1537 | or first_byte_pos not in xrange(0, numbytes)
1538 | or last_byte_pos not in xrange(0, numbytes)
1539 | ):
1540 | response = Response(
1541 | headers={
1542 | "ETag": "range%d" % numbytes,
1543 | "Accept-Ranges": "bytes",
1544 | "Content-Range": "bytes */%d" % numbytes,
1545 | "Content-Length": "0",
1546 | }
1547 | )
1548 | response.status_code = 416
1549 | return response
1550 |
1551 | def generate_bytes():
1552 | chunks = bytearray()
1553 |
1554 | for i in xrange(first_byte_pos, last_byte_pos + 1):
1555 |
1556 | # We don't want the resource to change across requests, so we need
1557 | # to use a predictable data generation function
1558 | chunks.append(ord("a") + (i % 26))
1559 | if len(chunks) == chunk_size:
1560 | yield (bytes(chunks))
1561 | time.sleep(pause_per_byte * chunk_size)
1562 | chunks = bytearray()
1563 |
1564 | if chunks:
1565 | time.sleep(pause_per_byte * len(chunks))
1566 | yield (bytes(chunks))
1567 |
1568 | content_range = "bytes %d-%d/%d" % (first_byte_pos, last_byte_pos, numbytes)
1569 | response_headers = {
1570 | "Content-Type": "application/octet-stream",
1571 | "ETag": "range%d" % numbytes,
1572 | "Accept-Ranges": "bytes",
1573 | "Content-Length": str(range_length),
1574 | "Content-Range": content_range,
1575 | }
1576 |
1577 | response = Response(generate_bytes(), headers=response_headers)
1578 |
1579 | if (first_byte_pos == 0) and (last_byte_pos == (numbytes - 1)):
1580 | response.status_code = 200
1581 | else:
1582 | response.status_code = 206
1583 |
1584 | return response
1585 |
1586 |
1587 | @app.route("/links//")
1588 | def link_page(n, offset):
1589 | """Generate a page containing n links to other pages which do the same.
1590 | ---
1591 | tags:
1592 | - Dynamic data
1593 | parameters:
1594 | - in: path
1595 | name: n
1596 | type: int
1597 | - in: path
1598 | name: offset
1599 | type: int
1600 | produces:
1601 | - text/html
1602 | responses:
1603 | 200:
1604 | description: HTML links.
1605 | """
1606 | n = min(max(1, n), 200) # limit to between 1 and 200 links
1607 |
1608 | link = "{1} "
1609 |
1610 | html = ["Links "]
1611 | for i in xrange(n):
1612 | if i == offset:
1613 | html.append("{0} ".format(i))
1614 | else:
1615 | html.append(link.format(url_for("link_page", n=n, offset=i), i))
1616 | html.append("")
1617 |
1618 | return "".join(html)
1619 |
1620 |
1621 | @app.route("/links/")
1622 | def links(n):
1623 | """Redirect to first links page."""
1624 | return redirect(url_for("link_page", n=n, offset=0))
1625 |
1626 |
1627 | @app.route("/image")
1628 | def image():
1629 | """Returns a simple image of the type suggest by the Accept header.
1630 | ---
1631 | tags:
1632 | - Images
1633 | produces:
1634 | - image/webp
1635 | - image/svg+xml
1636 | - image/jpeg
1637 | - image/png
1638 | - image/*
1639 | responses:
1640 | 200:
1641 | description: An image.
1642 | """
1643 |
1644 | headers = get_headers()
1645 | if "accept" not in headers:
1646 | return image_png() # Default media type to png
1647 |
1648 | accept = headers["accept"].lower()
1649 |
1650 | if "image/webp" in accept:
1651 | return image_webp()
1652 | elif "image/svg+xml" in accept:
1653 | return image_svg()
1654 | elif "image/jpeg" in accept:
1655 | return image_jpeg()
1656 | elif "image/png" in accept or "image/*" in accept:
1657 | return image_png()
1658 | else:
1659 | return status_code(406) # Unsupported media type
1660 |
1661 |
1662 | @app.route("/image/png")
1663 | def image_png():
1664 | """Returns a simple PNG image.
1665 | ---
1666 | tags:
1667 | - Images
1668 | produces:
1669 | - image/png
1670 | responses:
1671 | 200:
1672 | description: A PNG image.
1673 | """
1674 | data = resource("images/pig_icon.png")
1675 | return Response(data, headers={"Content-Type": "image/png"})
1676 |
1677 |
1678 | @app.route("/image/jpeg")
1679 | def image_jpeg():
1680 | """Returns a simple JPEG image.
1681 | ---
1682 | tags:
1683 | - Images
1684 | produces:
1685 | - image/jpeg
1686 | responses:
1687 | 200:
1688 | description: A JPEG image.
1689 | """
1690 | data = resource("images/jackal.jpg")
1691 | return Response(data, headers={"Content-Type": "image/jpeg"})
1692 |
1693 |
1694 | @app.route("/image/webp")
1695 | def image_webp():
1696 | """Returns a simple WEBP image.
1697 | ---
1698 | tags:
1699 | - Images
1700 | produces:
1701 | - image/webp
1702 | responses:
1703 | 200:
1704 | description: A WEBP image.
1705 | """
1706 | data = resource("images/wolf_1.webp")
1707 | return Response(data, headers={"Content-Type": "image/webp"})
1708 |
1709 |
1710 | @app.route("/image/svg")
1711 | def image_svg():
1712 | """Returns a simple SVG image.
1713 | ---
1714 | tags:
1715 | - Images
1716 | produces:
1717 | - image/svg+xml
1718 | responses:
1719 | 200:
1720 | description: An SVG image.
1721 | """
1722 | data = resource("images/svg_logo.svg")
1723 | return Response(data, headers={"Content-Type": "image/svg+xml"})
1724 |
1725 |
1726 | def resource(filename):
1727 | path = os.path.join(tmpl_dir, filename)
1728 | with open(path, "rb") as f:
1729 | return f.read()
1730 |
1731 |
1732 | @app.route("/xml")
1733 | def xml():
1734 | """Returns a simple XML document.
1735 | ---
1736 | tags:
1737 | - Response formats
1738 | produces:
1739 | - application/xml
1740 | responses:
1741 | 200:
1742 | description: An XML document.
1743 | """
1744 | response = make_response(render_template("sample.xml"))
1745 | response.headers["Content-Type"] = "application/xml"
1746 | return response
1747 |
1748 |
1749 | @app.route("/json")
1750 | def a_json_endpoint():
1751 | """Returns a simple JSON document.
1752 | ---
1753 | tags:
1754 | - Response formats
1755 | produces:
1756 | - application/json
1757 | responses:
1758 | 200:
1759 | description: An JSON document.
1760 | """
1761 | return flask_jsonify(
1762 | slideshow={
1763 | "title": "Sample Slide Show",
1764 | "date": "date of publication",
1765 | "author": "Yours Truly",
1766 | "slides": [
1767 | {"type": "all", "title": "Wake up to WonderWidgets!"},
1768 | {
1769 | "type": "all",
1770 | "title": "Overview",
1771 | "items": [
1772 | "Why WonderWidgets are great",
1773 | "Who buys WonderWidgets",
1774 | ],
1775 | },
1776 | ],
1777 | }
1778 | )
1779 |
1780 |
1781 | if __name__ == "__main__":
1782 | parser = argparse.ArgumentParser()
1783 | parser.add_argument("--port", type=int, default=5000)
1784 | parser.add_argument("--host", default="127.0.0.1")
1785 | args = parser.parse_args()
1786 | app.run(port=args.port, host=args.host)
1787 |
--------------------------------------------------------------------------------