pengyuthon/odoo_source
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c4bfaf3336a30eda4d12399cd93ee2ffd200d65a
odoo_source/odoo/addons/test_http/tests/test_static.py
T
Julien Castiaux da8def8e41 [IMP] core, web: Delegate delivery of static files 
Rationnals
----------

Web servers can serve some resources (e.g. static files) right away
without any interaction with the web application. The network model of
most web servers makes them capable of handling thousands of
simultaneous requests when it comes to intensive IO operations such as
streaming data from a file. The network model of Odoo is different: it
is capable of a lot of processing power but can only serve a handful of
requests at a time, i.e. Odoo (with some help from postgres) is
optimized for CPU operations, not IO.

Some users don't configure their web server, they use a basic
configuration that relay all requests to Odoo. The result is that many
Odoo HTTP Workers can be busy streaming static files instead of
processing other requests. This can lead to a worker starvation, i.e.
all workers are busy streaming files and cannot process new requests.

X-Sendfile
----------

In this work, we add the support for the [X-Sendfile] header family,
they are multiples http headers that can be used by the web application
to communicate with the web server in order to delegate the delivery of
files stored on the file system. Odoo still receives the request but it
does no more stream the file content from within its HTTP worker,
instead it skips the response body altogether and sets the `X-Sendfile`
special header with the path of the file on the filesystem. The web
server intercepts that special header, open the file and stream it.

Using those headers, we can use the best of both the web application and
the web server. The web application is still responsible to locate the
resource and verify the access rights, the web server is still
responsible of streaming the content.

Using X-Sendfile is opt-in via the `--x-sendfile` CLI flag. We set both
`X-Sendfile` (apache) and `X-Accel-Redirect` (nginx). If you are using
apache, make sure `mod_xsendfile` is enabled. If you are using NGINX
you have to add the following location block:

    location /web/filestore {  # custom path, hardcoded within Odoo
        # Prevent access from the outside world, i.e. makes this
        # route only accessible via X-Accel. MANDATORY!!!
        internal;

        # Give access to the filestore using this server's
        # permissions. Odoo is in charge of verifying the access
        # rights.
        alias /path/to/odoo/data-dir/filestore;
    }

The Odoo [deployment documentation] has been updated accordingly.

[X-Sendfile]: https://www.nginx.com/resources/wiki/start/topics/examples/xsendfile/
[deployment documentation]: https://www.odoo.com/documentation/master/administration/install/deploy.html#serving-static-files-and-attachments

Changes to the API
------------------

To benefit most from X-Sendfile, all APIs related to streaming content
over HTTP has to be adapted. They are: (1) `request._serve_static`,
(2) `ir.http._serve_fallback`, (3) `/web/content` and (4) `/web/image`.

Each used it own way to deliver content: (1) `_serve_static` was using
`send_file` (flask's send_file that as been vendored with odoo 10
years ago and not maintenained since then), (2) _serve_fallback was
handcrafting a `werkzeug.wrappers.Response`, (3) /web/content-image were
using the "binary server" `ir.http.binary_content` API.

I has been decided to remove all 3 APIs and to merge the code inside of
the new `http.Stream` object and the `ir.binary` helper model.

A Stream wraps what is going to be sent to the browser, it can be a path
to a file on the locale filesystem, a blob of raw data or an URL to an
external resource. The Stream also holds various metadata that are
mainly used for caching. The preferred way to create a Stream is via one
of its three factories so that all the metadata are set. The factories
are: `from_path`, `from_attachment` and `from_binary_field`. A stream
instance exposes a single method `get_response()` used to create the
corresponding HTTP response object out of the stream.

Inside of `ir.http` were a few methods that were not related to the http
routing and formed what was called the "binary server". All those
methods have been removed and the feature have been refactored inside of
the new `ir.binary` model. The removed methods are:

- `_xmlid_to_obj`
- `_get_record_and_check`
- `_binary_ir_attachment_redirect_content`
- `_binary_record_content`
- `_binary_set_headers`
- `binary_content`
- `_response_by_status`
- `_get_content_common`
- `_content_image`
- `_content_image_get_response`
- `_placeholder_image_get_response`

The new `ir.binary` abstract model exposes the following utilities:

**`_find_record`**

Find an attachment or a record with a binary-field out of an xmlid or
out of a pair record-model/record-id. Check the access rights and the
access token.

**`_get_stream_from`**

Create a Stream from an attachment or a record with a binary-field.

**`_get_image_stream_from`**

Same as `_get_stream_from` but adapted for images. It sets a sensible
ETag on the stream and has image resizing support.

**`_placeholder`**

Get the image placeholder blob.

Testing
-------

It is possible to test the web server configuration using the
`test_http` module. Install the module then run the unittest using the
`webserver` test-tag. By default it attempts to connect to a web-server
running on `http://localhost:80`, you can change this URL by setting the
`WEB_SERVER_URL` environment variable.

    odoo-bin -i test_http --stop-after-init
    WEB_SERVER_URL='http://localhost:80' odoo-bin --test-tags webserver --stop-after-init

closes odoo/odoo#88134

Task: 2801675
Related: odoo/documentation#2083
Related: odoo/enterprise#26191
Signed-off-by: Julien Castiaux <juc@odoo.com>
2022-06-01 02:53:59 +02:00

264 lines
11 KiB
Python
Raw Blame History

# Part of Odoo. See LICENSE file for full copyright and licensing details.
from datetime import datetime, timedelta
from os.path import basename, join as opj
from unittest.mock import patch
from freezegun import freeze_time
from odoo.tests import tagged
from odoo.tools import config, file_open
from .test_common import TestHttpBase
@tagged('post_install', '-at_install')
class TestHttpStaticCommon(TestHttpBase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls.classPatch(config, 'options', {**config.options, 'x_sendfile': False})
with file_open('test_http/static/src/img/gizeh.png', 'rb') as file:
cls.gizeh_data = file.read()
def assertDownload(
self, url, assert_status_code, assert_headers, assert_content=None
):
res = self.db_url_open(url)
res.raise_for_status()
self.assertEqual(res.status_code, assert_status_code)
for header_name, header_value in assert_headers.items():
self.assertEqual(res.headers.get(header_name), header_value)
if assert_content:
self.assertEqual(res.content, assert_content)
return res
def assertDownloadGizeh(self, url, x_sendfile=None, assert_filename='gizeh.png'):
headers = {
'Content-Length': '814',
'Content-Type': 'image/png',
'Content-Disposition': f'inline; filename={assert_filename}'
}
if x_sendfile:
sha = basename(x_sendfile)
headers['X-Sendfile'] = x_sendfile
headers['X-Accel-Redirect'] = f'/web/filestore/{self.cr.dbname}/{sha[:2]}/{sha}'
headers['Content-Length'] = '0'
return self.assertDownload(url, 200, headers, b'' if x_sendfile else self.gizeh_data)
@tagged('post_install', '-at_install')
class TestHttpStatic(TestHttpStaticCommon):
def test_static00_static(self):
with self.subTest(x_sendfile=False):
res = self.assertDownloadGizeh('/test_http/static/src/img/gizeh.png')
self.assertEqual(res.headers.get('Cache-Control', ''), 'public, max-age=604800')
with self.subTest(x_sendfile=True), \
patch.object(config, 'options', {**config.options, 'x_sendfile': True}):
# The file is outside of the filestore, X-Sendfile disabled
res = self.assertDownloadGizeh('/test_http/static/src/img/gizeh.png', x_sendfile=False)
self.assertEqual(res.headers.get('Cache-Control', ''), 'public, max-age=604800')
def test_static01_debug_assets(self):
session = self.authenticate(None, None)
session.debug = 'assets'
res = self.assertDownloadGizeh('/test_http/static/src/img/gizeh.png')
self.assertEqual(res.headers.get('Cache-Control', ''), 'no-cache, max-age=0')
def test_static02_not_found(self):
res = self.nodb_url_open("/test_http/static/i-dont-exist")
self.assertEqual(res.status_code, 404)
def test_static03_attachment_fallback(self):
attachment = self.env.ref('test_http.gizeh_png')
with self.subTest(x_sendfile=False):
self.assertDownloadGizeh(attachment.url)
with self.subTest(x_sendfile=True), \
patch.object(config, 'options', {**config.options, 'x_sendfile': True}):
self.assertDownloadGizeh(
attachment.url,
x_sendfile=opj(config.filestore(self.env.cr.dbname), attachment.store_fname),
)
def test_static04_web_content(self):
attachment = self.env.ref('test_http.gizeh_png')
with self.subTest(x_sendfile=False):
self.assertDownloadGizeh('/web/content/test_http.gizeh_png')
with self.subTest(x_sendfile=True), \
patch.object(config, 'options', {**config.options, 'x_sendfile': True}):
self.assertDownloadGizeh(
'/web/content/test_http.gizeh_png',
x_sendfile=opj(config.filestore(self.env.cr.dbname), attachment.store_fname),
)
def test_static05_web_image(self):
attachment = self.env.ref('test_http.gizeh_png')
with self.subTest(x_sendfile=False):
self.assertDownloadGizeh('/web/image/test_http.gizeh_png')
with self.subTest(x_sendfile=True), \
patch.object(config, 'options', {**config.options, 'x_sendfile': True}):
self.assertDownloadGizeh(
'/web/image/test_http.gizeh_png',
x_sendfile=opj(config.filestore(self.env.cr.dbname), attachment.store_fname),
)
def test_static06_attachment_internal_url(self):
with self.subTest(x_sendfile=False):
self.assertDownloadGizeh('/web/image/test_http.gizeh_url')
with self.subTest(x_sendfile=True), \
patch.object(config, 'options', {**config.options, 'x_sendfile': True}):
# The file is outside of the filestore, X-Sendfile disabled
self.assertDownloadGizeh('/web/image/test_http.gizeh_url', x_sendfile=False)
def test_static07_attachment_external_url(self):
res = self.db_url_open('/web/content/test_http.rickroll')
res.raise_for_status()
self.assertEqual(res.status_code, 301)
self.assertEqual(res.headers.get('Location'), 'https://www.youtube.com/watch?v=dQw4w9WgXcQ')
def test_static08_binary_field_attach(self):
earth = self.env.ref('test_http.earth')
attachment = self.env['ir.attachment'].search([
('res_model', '=', 'test_http.stargate'),
('res_id', '=', earth.id),
('res_field', '=', 'glyph_attach')
], limit=1)
attachment_path = opj(config.filestore(self.env.cr.dbname), attachment.store_fname)
with self.subTest(x_sendfile=False):
self.assertDownloadGizeh(
f'/web/content/test_http.stargate/{earth.id}/glyph_attach',
assert_filename='Earth.png'
)
with self.subTest(x_sendfile=True), \
patch.object(config, 'options', {**config.options, 'x_sendfile': True}):
self.assertDownloadGizeh(
f'/web/content/test_http.stargate/{earth.id}/glyph_attach',
x_sendfile=attachment_path,
assert_filename='Earth.png'
)
def test_static09_binary_field_inline(self):
self.assertDownloadGizeh(
'/web/content/test_http.earth?field=glyph_inline',
assert_filename='Earth.png'
)
def test_static10_filename(self):
with self.subTest("record name"):
self.assertDownloadGizeh(
'/web/content/test_http.gizeh_png',
assert_filename='gizeh.png',
)
with self.subTest("forced name"):
self.assertDownloadGizeh(
'/web/content/test_http.gizeh_png?filename=pyramid.png',
assert_filename='pyramid.png',
)
with self.subTest("filename field"):
self.assertDownloadGizeh(
'/web/content/test_http.earth?field=glyph_inline&filename_field=address',
assert_filename='sq5Abt.png',
)
def test_static11_bad_filenames(self):
with self.subTest("missing record name"):
gizeh = self.env.ref('test_http.gizeh_png')
realname = gizeh.name
gizeh.name = ''
try:
self.assertDownloadGizeh(
'/web/content/test_http.gizeh_png',
assert_filename=f'ir_attachment-{gizeh.id}-raw.png'
)
finally:
gizeh.name = realname
with self.subTest("missing file extension"):
self.assertDownloadGizeh(
'/web/content/test_http.gizeh_png?filename=pyramid',
assert_filename='pyramid.png',
)
with self.subTest("wrong file extension"):
res = self.assertDownloadGizeh(
'/web/content/test_http.gizeh_png?filename=pyramid.jpg',
assert_filename='pyramid.jpg',
)
self.assertEqual(res.headers['Content-Type'], 'image/png')
with self.subTest("dotted name"):
res = self.assertDownloadGizeh(
'/web/content/test_http.gizeh_png?filename=pyramid.of.gizeh',
assert_filename='pyramid.of.gizeh.png',
)
class TestHttpStaticCache(TestHttpStaticCommon):
@freeze_time(datetime.utcnow())
def test_static_cache0_standard(self, domain=''):
# Wed, 21 Oct 2015 07:28:00 GMT
# The timezone should be %Z (instead of 'GMT' hardcoded) but
# somehow strftime doesn't set it.
http_date_format = '%a, %d %b %Y %H:%M:%S GMT'
one_week_away = (datetime.utcnow() + timedelta(weeks=1)).strftime(http_date_format)
res1 = self.nodb_url_open(f'{domain}/test_http/static/src/img/gizeh.png')
res1.raise_for_status()
self.assertEqual(res1.status_code, 200)
self.assertEqual(res1.headers.get('Cache-Control'), 'public, max-age=604800') # one week
self.assertEqual(res1.headers.get('Expires'), one_week_away)
self.assertIn('ETag', res1.headers)
res2 = self.nodb_url_open(f'{domain}/test_http/static/src/img/gizeh.png', headers={
'If-None-Match': res1.headers['ETag']
})
res2.raise_for_status()
self.assertEqual(res2.status_code, 304, "We should not download the file again.")
@freeze_time(datetime.utcnow())
def test_static_cache1_unique(self, domain=''):
# Wed, 21 Oct 2015 07:28:00 GMT
# The timezone should be %Z (instead of 'GMT' hardcoded) but
# somehow strftime doesn't set it.
http_date_format = '%a, %d %b %Y %H:%M:%S GMT'
one_year_away = (datetime.utcnow() + timedelta(days=365)).strftime(http_date_format)
res1 = self.assertDownloadGizeh(f'{domain}/web/content/test_http.gizeh_png?unique=1')
self.assertEqual(res1.headers.get('Cache-Control'), 'public, max-age=31536000') # one year
self.assertEqual(res1.headers.get('Expires'), one_year_away)
self.assertIn('ETag', res1.headers)
res2 = self.db_url_open(f'{domain}/web/content/test_http.gizeh_png?unique=1', headers={
'If-None-Match': res1.headers['ETag']
})
res2.raise_for_status()
self.assertEqual(res2.status_code, 304, "We should not download the file again.")
@freeze_time(datetime.utcnow())
def test_static_cache2_nocache(self, domain=''):
res1 = self.assertDownloadGizeh(f'{domain}/web/content/test_http.gizeh_png?nocache=1')
self.assertEqual(res1.headers.get('Cache-Control'), 'no-cache')
self.assertNotIn('Expires', res1.headers)
self.assertIn('ETag', res1.headers)
res2 = self.db_url_open(f'{domain}/web/content/test_http.gizeh_png?nocache=1', headers={
'If-None-Match': res1.headers['ETag']
})
res2.raise_for_status()
self.assertEqual(res2.status_code, 304, "We should not download the file again.")
Reference in New Issue View Git Blame Copy Permalink