Compare commits
No commits in common. "master" and "13-acl" have entirely different histories.
|
|
@ -137,7 +137,3 @@ dmypy.json
|
|||
cython_debug/
|
||||
|
||||
domains/
|
||||
.vscode
|
||||
|
||||
# Vim swap files
|
||||
*.swp
|
||||
|
|
|
|||
|
|
@ -1,90 +0,0 @@
|
|||
# This file is a template, and might need editing before it works on your project.
|
||||
# To contribute improvements to CI/CD templates, please follow the Development guide at:
|
||||
# https://docs.gitlab.com/ee/development/cicd/templates.html
|
||||
# This specific template is located at:
|
||||
# https://gitlab.com/gitlab-org/gitlab/-/blob/master/lib/gitlab/ci/templates/Python.gitlab-ci.yml
|
||||
|
||||
# Official language image. Look for the different tagged releases at:
|
||||
# https://hub.docker.com/r/library/python/tags/
|
||||
image: python:alpine3.18
|
||||
|
||||
# Change pip's cache directory to be inside the project directory since we can
|
||||
# only cache local items.
|
||||
variables:
|
||||
PIP_CACHE_DIR: "$CI_PROJECT_DIR/.cache/pip"
|
||||
# REGISTRY_USERNAME - secret variable
|
||||
# REGISTRY_PASSWORD - secret variable
|
||||
# REGISTRY_SERVER - secret variable
|
||||
IMAGE_NAME: ${REGISTRY_SERVER}/malves/${CI_PROJECT_NAME}
|
||||
|
||||
# Pip's cache doesn't store the python packages
|
||||
# https://pip.pypa.io/en/stable/reference/pip_install/#caching
|
||||
#
|
||||
# If you want to also cache the installed packages, you have to install
|
||||
# them in a virtualenv and cache it as well.
|
||||
cache:
|
||||
paths:
|
||||
- .cache/pip
|
||||
- venv/
|
||||
|
||||
stages:
|
||||
- test
|
||||
- build
|
||||
|
||||
.before_script_template: &test
|
||||
before_script:
|
||||
- python3 -V # Print out python version for debugging
|
||||
- python3 -m venv /tmp/venv
|
||||
- /tmp/venv/bin/pip3 install .["tests","pyexcel"]
|
||||
- /tmp/venv/bin/pip3 install coverage pytest
|
||||
|
||||
test:
|
||||
image: python:alpine${ALPINEVERSION}
|
||||
stage: test
|
||||
<<: *test
|
||||
parallel:
|
||||
matrix:
|
||||
- ALPINEVERSION: ["3.16", "3.17", "3.18", "3.19"]
|
||||
script:
|
||||
- /tmp/venv/bin/pytest --version
|
||||
- PYTHONPATH=./tests/ /tmp/venv/bin/coverage run --source halfapi -m pytest
|
||||
- /tmp/venv/bin/coverage xml
|
||||
- /tmp/venv/bin/halfapi --version
|
||||
|
||||
artifacts:
|
||||
reports:
|
||||
coverage_report:
|
||||
coverage_format: cobertura
|
||||
path: coverage.xml
|
||||
|
||||
build_pypi:
|
||||
stage: build
|
||||
script:
|
||||
- python3 -V # Print out python version for debugging
|
||||
- python3 -m venv /tmp/venv
|
||||
- /tmp/venv/bin/pip3 install .
|
||||
artifacts:
|
||||
paths:
|
||||
- dist/*.whl
|
||||
rules:
|
||||
- if: '$CI_COMMIT_TAG != ""'
|
||||
variables:
|
||||
TAG: $CI_COMMIT_TAG
|
||||
|
||||
build_container:
|
||||
rules:
|
||||
- if: '$CI_COMMIT_TAG != ""'
|
||||
variables:
|
||||
IMGTAG: $CI_COMMIT_TAG
|
||||
- if: '$CI_COMMIT_REF_NAME == "devel"'
|
||||
variables:
|
||||
IMGTAG: "latest"
|
||||
stage: build
|
||||
image: $CI_REGISTRY/devtools/kaniko
|
||||
script:
|
||||
- echo "Will upload image halfapi:\"$IMGTAG\""
|
||||
- echo "{\"auths\":{\"$CI_REGISTRY\":{\"username\":\"$CI_REGISTRY_USER\",\"password\":\"$CI_REGISTRY_PASSWORD\"}}}" > /kaniko/.docker/config.json
|
||||
- /kaniko/executor --force --context $CI_PROJECT_DIR --dockerfile $CI_PROJECT_DIR/Dockerfile --destination $CI_REGISTRY/malves/halfapi:"$IMGTAG"
|
||||
artifacts:
|
||||
paths:
|
||||
- /kaniko/.docker/config.json
|
||||
228
CHANGELOG.md
228
CHANGELOG.md
|
|
@ -1,233 +1,5 @@
|
|||
# HalfAPI
|
||||
|
||||
## 0.6.30
|
||||
|
||||
Dependencies updates
|
||||
|
||||
- pyYAML v6.0.1
|
||||
- starlette v0.37.2
|
||||
|
||||
Warning : the on_startup halfAPI argument is now removed, use the lifeSpan
|
||||
|
||||
## 0.6.29
|
||||
|
||||
### Dependencies
|
||||
|
||||
Starlette version bumped to 0.33.
|
||||
|
||||
## 0.6.28
|
||||
|
||||
### Dependencies
|
||||
|
||||
Starlette version bumped to 0.31 (had to disable a test to make it work but
|
||||
seems not important).
|
||||
|
||||
### Development dependencies
|
||||
|
||||
Python 3.7 is no longer supported (openapi_spec_validator is not compatible).
|
||||
|
||||
If you are a developper, you should update dev dependencies in your virtual
|
||||
environment.
|
||||
|
||||
### OpenAPI schemas
|
||||
|
||||
This release improves OpenAPI specification in routes, and gives a default
|
||||
"parameters" field for routes that have path parameters.
|
||||
|
||||
Also, if you use halfAPI for multi-domain setups, you may be annoyed by the
|
||||
change in the return value of the "/" route that differs from "/domain" route.
|
||||
|
||||
An HalfAPI instance should return one and only one OpenAPI Schema, so you can
|
||||
rely on it to connect to other software.
|
||||
|
||||
The version number that is contained under the "info" dictionnary is now the "version"
|
||||
of the Api domain, as specified in the domain dictionnary specified at the root
|
||||
of the Domain.
|
||||
|
||||
The title field of the "info" dictionnary is now the Domain's name.
|
||||
|
||||
The ACLs list is now available under the "info.x-acls" attribute of the schema.
|
||||
It is still accessible from the "/halfapi/acls" route.
|
||||
|
||||
#### Schema Components
|
||||
|
||||
You can now specify a dict in the domain's metadata dict that follows the
|
||||
"components" key of an OpenAPI schema.
|
||||
|
||||
Use it to define models that are used in your API. You can see an exemple of
|
||||
it's use in the "tests/dummy_domain/__init__.py" file.
|
||||
|
||||
|
||||
### ACLs
|
||||
|
||||
The use of an "HEAD" request to check an ACL is now the norm. Please change all
|
||||
the occurrences of your calls on theses routes with the GET method.
|
||||
|
||||
|
||||
### CLI
|
||||
|
||||
Domain command update :
|
||||
|
||||
The `--conftest` flag is now allowed when running the `domain` command, it dumps the current configuration as a TOML string.
|
||||
|
||||
`halfapi domain --conftest my_domain`
|
||||
|
||||
|
||||
The `--dry-run` flag was buggy and is now fixed when using the `domai ` command with the `--run` flag.
|
||||
|
||||
|
||||
### Configuration
|
||||
|
||||
The `port` option in a `domain.my_domain` section in the TOML config file is now prefered to the one in the `project` section.
|
||||
|
||||
The `project` section is used as a default section for the whole configuration file. - Tests still have to be written -
|
||||
|
||||
The standard configuration precedence is fixed, in this order from the hight to the lower :
|
||||
|
||||
- Argument value (i.e. : --log-level)
|
||||
- Environment value (i.e. : HALFAPI_LOGLEVEL)
|
||||
- Configuration value under "domain" key
|
||||
- Configuration value under "project" key
|
||||
- Default configuration value given in the "DEFAULT_CONF" dictionary of halfapi/conf.py
|
||||
|
||||
### Logs
|
||||
|
||||
Small cleanup of the logs levels. If you don't want the config to be dumped, just set the HALFAPI_LOGLEVEL to something different than "DEBUG".
|
||||
|
||||
### Fixes
|
||||
|
||||
- Check an ACL based on a decorator on "/halfapi/acls/MY_ACL"
|
||||
|
||||
## 0.6.27
|
||||
|
||||
### Breaking changes
|
||||
|
||||
- ACLs definition can now include a "public" parameter that defines if there should be an automatic creation of a route to check this acls
|
||||
- /halfapi/acls does not return the "result", it just returns if there is a public route to check the ACL on /halfapi/acls/acl_name
|
||||
=======
|
||||
argument of starlette instead.
|
||||
>>>>>>> a8c59c6 ([release] halfapi 0.6.27)
|
||||
|
||||
## 0.6.26
|
||||
|
||||
- Adds the "base_url", "cookies" and "url" to the "halfapi" argument of route definitions
|
||||
|
||||
## 0.6.25
|
||||
|
||||
- Deletes the "Authorization" cookie on authentication error
|
||||
- Do not raise an exception on signature expiration, use "Nobody" user instead
|
||||
|
||||
## 0.6.24
|
||||
|
||||
- Uses the "Authorization" cookie to read authentication token additionnaly to the "Authorization" header
|
||||
- CLI : allows to run a single domain using the "halfapi domain --run domain_name" command
|
||||
|
||||
## 0.6.23
|
||||
|
||||
Dependency update version
|
||||
|
||||
- starlette v0.23
|
||||
- orjson v3.8.5
|
||||
- click v8
|
||||
- pyJWT v2.6
|
||||
- pyYAML v6
|
||||
- toml v0.10
|
||||
|
||||
## 0.6.22
|
||||
|
||||
- IMPORTANT : Fix bug introduced with 0.6.20 (fix arguments handling)
|
||||
- BREAKING : A domain should now include it's meta datas in a "domain" dictionary located in the __init__.py file of the domain's root. Consider looking in 'tests/dummy_domain/__init__.py'
|
||||
- Add *html* return type as default argument ret_type
|
||||
- Add *txt* return type
|
||||
- Log unhandled exceptions
|
||||
- Log HTTPException with statuscode 500 as critical
|
||||
- PyJWT >=2.4.0,<2.5.0
|
||||
|
||||
|
||||
## 0.6.21
|
||||
|
||||
- Store only domain's config in halfapi['config']
|
||||
- Should run halfapi domain with config_file argument
|
||||
- Testing : You can specify a "MODULE" attribute to point out the path to the Api's base module
|
||||
- Testing : You can specify a "CONFIG" attribute to set the domain's testing configuration
|
||||
- Environment : HALFAPI_DOMAIN_MODULE can be set to specify Api's base module
|
||||
- Config : 'module' attribute can be set to specify Api's base module
|
||||
|
||||
## 0.6.20
|
||||
|
||||
- Fix arguments handling
|
||||
|
||||
## 0.6.19
|
||||
|
||||
- Allow file sending in multipart request (#32)
|
||||
- Add python-multipart dependency
|
||||
|
||||
## 0.6.18
|
||||
|
||||
- Fix config coming from .halfapi/config when using HALFAPI_DOMAIN_NAME environment variable
|
||||
|
||||
## 0.6.17
|
||||
|
||||
- Fix 0.6.16
|
||||
- Errata : HALFAPI_DOMAIN is HALFAPI_DOMAIN_NAME
|
||||
- Testing : You can now specify "MODULE" class attribute for your "test_domain"
|
||||
subclasses
|
||||
|
||||
## 0.6.16
|
||||
|
||||
- The definition of "HALFAPI_DOMAIN_MODULE" environment variable allows to
|
||||
specify the base module for a domain structure. It is formatted as a python
|
||||
import path.
|
||||
The "HALFAPI_DOMAIN" specifies the "name" of the module
|
||||
|
||||
## 0.6.15
|
||||
|
||||
- Allows to define a "__acl__" variable in the API module's __init__.py, to
|
||||
specify how to import the acl lib. You can also specify "acl" in the domain's
|
||||
config
|
||||
|
||||
## 0.6.14
|
||||
|
||||
- Add XLSXResponse (with format argument set to "xlsx"), to return .xlsx files
|
||||
|
||||
## 0.6.13
|
||||
|
||||
- (rollback from 0.6.12) Remove pytest from dependencies in Docker file and
|
||||
remove tests
|
||||
- (dep) Add "packaging" dependency
|
||||
- Add dependency check capability when instantiating a domain (__deps__
|
||||
variable, see in dummy_domain)
|
||||
|
||||
## 0.6.12
|
||||
|
||||
- Installs pytest with dependencies in Docker image, tests when building image
|
||||
|
||||
## 0.6.11
|
||||
|
||||
- Fix "request" has no "path_params" attribute bug
|
||||
|
||||
## 0.6.10
|
||||
|
||||
- Add "x-out" field in HTTP headers when "out" parameters are specified for a
|
||||
route
|
||||
- Add "out" kwarg for not-async functions that specify it
|
||||
|
||||
## 0.6.9
|
||||
|
||||
- Hide data fields in args_check logs
|
||||
|
||||
## 0.6.8
|
||||
|
||||
- Fix testing lib for domains (add default secret and debug option)
|
||||
|
||||
## 0.6.2
|
||||
|
||||
- Domains now need to include the following variables in their __init__.py
|
||||
- __name__ (str, optional)
|
||||
- __id__ (str, optional)
|
||||
- halfapi domain
|
||||
|
||||
|
||||
## 0.1.0
|
||||
|
||||
- Mounts domain routers with their ACLs as decorator
|
||||
|
|
|
|||
11
Dockerfile
11
Dockerfile
|
|
@ -1,11 +0,0 @@
|
|||
# syntax=docker/dockerfile:1
|
||||
FROM python:alpine3.19
|
||||
COPY . /halfapi
|
||||
WORKDIR /halfapi
|
||||
ENV VENV_DIR=/opt/venv
|
||||
RUN mkdir -p $VENV_DIR
|
||||
RUN python -m venv $VENV_DIR
|
||||
RUN $VENV_DIR/bin/pip install gunicorn uvicorn
|
||||
RUN $VENV_DIR/bin/pip install .
|
||||
RUN ln -s $VENV_DIR/bin/halfapi /usr/local/bin/
|
||||
CMD $VENV_DIR/bin/gunicorn halfapi.app
|
||||
|
|
@ -1,5 +1,4 @@
|
|||
Copyright (c) 2020-2021 Maxime ALVES <maxime@freepoteries.fr>, Joël Maïzi
|
||||
<joel.maizi@collorg.org>
|
||||
Copyright (c) 2015-2020 Joël Maïzi <joel.maizi@collorg.org>
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
33
Pipfile
33
Pipfile
|
|
@ -4,33 +4,18 @@ url = "https://pypi.org/simple"
|
|||
verify_ssl = true
|
||||
|
||||
[dev-packages]
|
||||
pytest = ">=7,<8"
|
||||
pytest = "*"
|
||||
requests = "*"
|
||||
pytest-asyncio = "*"
|
||||
pylint = "*"
|
||||
build = "*"
|
||||
twine = "*"
|
||||
pyflakes = "*"
|
||||
vulture = "*"
|
||||
virtualenv = "*"
|
||||
httpx = "*"
|
||||
openapi-schema-validator = "*"
|
||||
openapi-spec-validator = "*"
|
||||
coverage = "*"
|
||||
|
||||
[packages]
|
||||
click = ">=8,<9"
|
||||
starlette = ">=0.37,<0.38"
|
||||
uvicorn = ">=0.13,<1"
|
||||
orjson = ">=3.8.5,<4"
|
||||
pyjwt = ">=2.6.0,<2.7.0"
|
||||
pyyaml = ">=6.0.1,<7"
|
||||
timing-asgi = ">=0.2.1,<1"
|
||||
schema = ">=0.7.4,<1"
|
||||
toml = ">=0.10,<0.11"
|
||||
pip = "*"
|
||||
packaging = ">=19.0"
|
||||
python-multipart = "*"
|
||||
click = "*"
|
||||
starlette = "*"
|
||||
uvicorn = "*"
|
||||
jwt = "*"
|
||||
|
||||
[requires]
|
||||
python_version = "3.7"
|
||||
|
||||
[scripts]
|
||||
halfapi = "python -m halfapi"
|
||||
halfapi = "halfapi.cli.cli:cli"
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
126
README.md
126
README.md
|
|
@ -1,9 +1,18 @@
|
|||
# HalfAPI
|
||||
|
||||
Base tools to develop complex API with rights management.
|
||||
|
||||
This project was developped by Maxime Alves and Joël Maïzi. The name was chosen
|
||||
to reference [HalfORM](https://github.com/collorg/halfORM), a project written by Joël Maïzi.
|
||||
This Python-based ASGI application aims to provide the core functionality to
|
||||
multiple API domains.
|
||||
|
||||
It's developed at the [LIRMM](https://lirmm.fr) in Montpellier, France.
|
||||
|
||||
The name "halfAPI" comes from the deep relationship between it and
|
||||
[halfORM](https://gite.lirmm.fr/newsi/halfORM), a project authored by
|
||||
[Joël Maizi](https://gite.lirmm.fr/maizi).
|
||||
|
||||
You'll need a database with the API details. You can find the database model in halfapi/models/api.sql
|
||||
|
||||
**TODO :** include a token generation tool for testing purpose.
|
||||
|
||||
|
||||
## Dependencies
|
||||
|
|
@ -11,94 +20,67 @@ to reference [HalfORM](https://github.com/collorg/halfORM), a project written by
|
|||
- python3
|
||||
- python3-pip
|
||||
- libgit2-dev
|
||||
- starlette
|
||||
- PyJWT
|
||||
- click
|
||||
- uvicorn
|
||||
- orjson
|
||||
- pyyaml
|
||||
|
||||
|
||||
## Configuration
|
||||
|
||||
Configure HalfAPI in the file : .halfapi/config .
|
||||
|
||||
It's a **toml** file that contains at least two sections, project and domains.
|
||||
|
||||
https://toml.io/en/
|
||||
## Installing
|
||||
|
||||
|
||||
### Project
|
||||
With local folder :
|
||||
|
||||
The main configuration options without which HalfAPI cannot be run.
|
||||
|
||||
**secret** : The file containing the secret to decode the user's tokens.
|
||||
|
||||
**port** : The port for the test server.
|
||||
|
||||
**loglevel** : The log level (info, debug, critical, ...)
|
||||
`pip3 install -r requirements.txt .[cli]`
|
||||
|
||||
|
||||
### Domains
|
||||
From the repository :
|
||||
|
||||
`pip3 install git+ssh://git@gite.lirmm.fr:malves/halfapi.git[cli]`
|
||||
|
||||
|
||||
## CLI usage
|
||||
|
||||
|
||||
## Running
|
||||
|
||||
### Development mode
|
||||
|
||||
In the project's folder :
|
||||
|
||||
`halfapi run`
|
||||
|
||||
|
||||
### Production
|
||||
|
||||
The production server may use different init systems. As our main server is Debian-based, we use systemd services to manage the api server. Find the right service files and configure them properly in order to make your production setup perfect.
|
||||
|
||||
Specify the domains configurations in the following form :
|
||||
|
||||
```
|
||||
[domains.DOMAIN_NAME]
|
||||
name = "DOMAIN_NAME"
|
||||
enabled = true
|
||||
prefix = "/prefix"
|
||||
module = "domain_name.path.to.api.root"
|
||||
port = 1002
|
||||
cp conf/systemd/lirmm_api* /etc/systemd/system/
|
||||
systemctl daemon-reload
|
||||
systemctl start lirmm_api
|
||||
```
|
||||
|
||||
Specific configuration can be done under the "config" section :
|
||||
|
||||
To make it start at boot :
|
||||
|
||||
|
||||
`systemctl enable lirmm_api`
|
||||
|
||||
|
||||
|
||||
To get the logs :
|
||||
|
||||
|
||||
```
|
||||
[domains.DOMAIN_NAME.config]
|
||||
boolean_option = false
|
||||
string_value = "String"
|
||||
answer = 42
|
||||
listylist = ["hello", "world"]
|
||||
```
|
||||
|
||||
And can be accessed through the app's "config" dictionnary.
|
||||
|
||||
|
||||
## Usage
|
||||
|
||||
Develop an HalfAPI domain by following the examples located in
|
||||
tests/dummy_domain . An HalfAPI domain should be an importable python module
|
||||
that is available in the python path.
|
||||
|
||||
Run the project by using the `halfapi run` command.
|
||||
|
||||
You can try the dummy_domain with the following command.
|
||||
journalctl -f --unit lirmm_api
|
||||
|
||||
```
|
||||
PYTHONPATH=$PWD/tests python -m halfapi domain dummy_domain
|
||||
```
|
||||
|
||||
### CLI documentation
|
||||
|
||||
Use the CLI help.
|
||||
|
||||
```
|
||||
python -m halfapi --help
|
||||
python -m halfapi domain --help
|
||||
```
|
||||
|
||||
## API Testing
|
||||
|
||||
@TODO
|
||||
|
||||
|
||||
### Example
|
||||
## Testing
|
||||
|
||||
Check out the [sample project](https://github.com/halfAPI/halfapi_sample_project)
|
||||
that helps you to build your own domain.
|
||||
### Installing
|
||||
|
||||
pip3 install .[cli][tests]
|
||||
|
||||
## Development
|
||||
### Running
|
||||
|
||||
@TODO
|
||||
pytest -v
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
#!/usr/bin/env python3
|
||||
__version__ = '0.6.30'
|
||||
__version__ = '0.1.0'
|
||||
|
||||
def version():
|
||||
return f'HalfAPI version:{__version__}'
|
||||
|
|
|
|||
|
|
@ -1,3 +0,0 @@
|
|||
from .cli.cli import cli
|
||||
if __name__ == '__main__':
|
||||
cli()
|
||||
|
|
@ -1,7 +1,45 @@
|
|||
import os
|
||||
from .halfapi import HalfAPI
|
||||
from .logging import logger
|
||||
#!/usr/bin/env python3
|
||||
# asgi framework
|
||||
from starlette.applications import Starlette
|
||||
from starlette.authentication import UnauthenticatedUser
|
||||
from starlette.middleware import Middleware
|
||||
from starlette.responses import Response, JSONResponse
|
||||
from starlette.routing import Route
|
||||
from starlette.middleware.authentication import AuthenticationMiddleware
|
||||
|
||||
def application():
|
||||
from .conf import CONFIG
|
||||
return HalfAPI(CONFIG).application
|
||||
# typing
|
||||
from typing import Any, Awaitable, Callable, MutableMapping
|
||||
|
||||
# module libraries
|
||||
from halfapi.conf import HOST, PORT, DB_NAME, SECRET, PRODUCTION
|
||||
|
||||
from halfapi.lib.jwt_middleware import JWTAuthenticationBackend
|
||||
|
||||
from halfapi.lib.responses import *
|
||||
from halfapi.lib.routes import get_routes
|
||||
|
||||
|
||||
debug_routes = [
|
||||
Route('/', lambda request, *args, **kwargs: PlainTextResponse('It Works!')),
|
||||
Route('/user', lambda request, *args, **kwargs:
|
||||
JSONResponse({'user':request.user.json})
|
||||
if type(request.user) != UnauthenticatedUser
|
||||
else JSONResponse({'user':False})),
|
||||
Route('/payload', lambda request, *args, **kwargs:
|
||||
JSONResponse({'payload':str(request.payload)}))
|
||||
] if not PRODUCTION else []
|
||||
|
||||
application = Starlette(
|
||||
debug=not PRODUCTION,
|
||||
routes=debug_routes + get_routes(),
|
||||
middleware=[
|
||||
Middleware(AuthenticationMiddleware,
|
||||
backend=JWTAuthenticationBackend(secret_key=SECRET))
|
||||
],
|
||||
exception_handlers={
|
||||
401: UnauthorizedResponse,
|
||||
404: NotFoundResponse,
|
||||
500: InternalServerErrorResponse,
|
||||
501: NotImplementedResponse
|
||||
}
|
||||
)
|
||||
|
|
|
|||
|
|
@ -0,0 +1 @@
|
|||
#!/usr/bin/env
|
||||
|
|
@ -1,28 +1,20 @@
|
|||
#!/usr/bin/env python3
|
||||
"""
|
||||
cli/cli.py Main entry point of halfapi cli tool
|
||||
|
||||
The init command is the only command loaded if not in a *project dir*, and it is
|
||||
not loaded otherwise.
|
||||
"""
|
||||
# builtins
|
||||
import click
|
||||
from halfapi.conf import IS_PROJECT
|
||||
|
||||
@click.group(invoke_without_command=True)
|
||||
@click.option('--version', is_flag=True)
|
||||
@click.pass_context
|
||||
def cli(ctx, version):
|
||||
"""
|
||||
HalfAPI Cli entry point
|
||||
|
||||
It uses the Click library
|
||||
"""
|
||||
if version:
|
||||
from halfapi import version
|
||||
click.echo(version())
|
||||
import halfapi
|
||||
return click.echo(halfapi.version())
|
||||
|
||||
from . import config
|
||||
from . import domain
|
||||
from . import run
|
||||
from . import init
|
||||
from . import routes
|
||||
if IS_PROJECT:
|
||||
import halfapi.cli.config
|
||||
import halfapi.cli.domain
|
||||
import halfapi.cli.run
|
||||
|
||||
else:
|
||||
import halfapi.cli.init
|
||||
|
|
|
|||
|
|
@ -1,31 +1,34 @@
|
|||
#!/usr/bin/env python3
|
||||
"""
|
||||
cli/config.py Contains the .halfapi/config
|
||||
|
||||
Defines the "halfapi config" command
|
||||
"""
|
||||
import click
|
||||
|
||||
from .cli import cli
|
||||
from ..conf import CONFIG
|
||||
from halfapi.conf import (
|
||||
PROJECT_NAME,
|
||||
DOMAINS,
|
||||
CONF_DIR,
|
||||
HOST,
|
||||
PORT,
|
||||
DB_NAME,
|
||||
PRODUCTION,
|
||||
BASE_DIR
|
||||
)
|
||||
|
||||
DOMAIN_CONF_STR="""
|
||||
[domain]
|
||||
name = {name}
|
||||
router = {router}
|
||||
"""
|
||||
|
||||
CONF_STR="""
|
||||
CONF_STR=f"""
|
||||
[project]
|
||||
host = {host}
|
||||
port = {port}
|
||||
production = {production}
|
||||
"""
|
||||
name = {PROJECT_NAME}
|
||||
host = {HOST}
|
||||
port = {PORT}
|
||||
production = {PRODUCTION}
|
||||
base_dir = {BASE_DIR}
|
||||
|
||||
[domains]"""
|
||||
|
||||
for dom in DOMAINS:
|
||||
CONF_STR = '\n'.join((CONF_STR, dom))
|
||||
|
||||
@cli.command()
|
||||
def config():
|
||||
"""
|
||||
Lists config parameters and their values
|
||||
"""
|
||||
click.echo(CONF_STR.format(**CONFIG))
|
||||
click.echo(CONF_STR)
|
||||
|
|
|
|||
|
|
@ -1,242 +1,306 @@
|
|||
#!/usr/bin/env python3
|
||||
"""
|
||||
cli/domain.py Defines the "halfapi domain" cli commands
|
||||
"""
|
||||
# builtins
|
||||
import os
|
||||
import sys
|
||||
import importlib
|
||||
import subprocess
|
||||
|
||||
import json
|
||||
import toml
|
||||
|
||||
import logging
|
||||
import click
|
||||
import orjson
|
||||
import uvicorn
|
||||
|
||||
|
||||
import importlib
|
||||
from .cli import cli
|
||||
from ..conf import CONFIG
|
||||
from halfapi.conf import DOMAINS, BASE_DIR
|
||||
from halfapi.db import (
|
||||
Domain,
|
||||
APIRouter,
|
||||
APIRoute,
|
||||
AclFunction,
|
||||
Acl)
|
||||
|
||||
from ..half_domain import HalfDomain
|
||||
|
||||
from ..lib.routes import api_routes
|
||||
from ..lib.responses import ORJSONResponse
|
||||
from ..conf import CONFIG, PROJECT_LEVEL_KEYS
|
||||
|
||||
|
||||
from ..logging import logger
|
||||
logger = logging.getLogger('halfapi')
|
||||
|
||||
#################
|
||||
# domain create #
|
||||
#################
|
||||
def create_domain(domain_name: str, module_path: str):
|
||||
logger.info('Will add **%s** (%s) to current halfAPI project',
|
||||
domain_name, module_path)
|
||||
|
||||
#if domain_name in DOMAINSDICT():
|
||||
# logger.warning('Domain **%s** is already in project', domain_name)
|
||||
# sys.exit(1)
|
||||
|
||||
def domain_tree_create():
|
||||
def create_init(path):
|
||||
with open(os.path.join(os.getcwd(), path, '__init__.py'), 'w') as f:
|
||||
f.writelines([
|
||||
'"""',
|
||||
f'name: {domain_name}',
|
||||
f'router: {module_path}',
|
||||
'"""'
|
||||
])
|
||||
logger.debug('created %s', os.path.join(os.getcwd(), path, '__init__.py'))
|
||||
|
||||
def create_acl(path):
|
||||
with open(os.path.join(path, 'acl.py'), 'w') as f:
|
||||
f.writelines([
|
||||
'from halfapi.lib.acl import public, ACLS',
|
||||
|
||||
])
|
||||
logger.debug('created %s', os.path.join(path, 'acl.py'))
|
||||
|
||||
|
||||
os.mkdir(domain_name)
|
||||
create_init(domain_name)
|
||||
router_path = os.path.join(domain_name, 'routers')
|
||||
create_acl(domain_name)
|
||||
os.mkdir(router_path)
|
||||
create_init(router_path)
|
||||
|
||||
# TODO: Generate config file
|
||||
|
||||
domain_tree_create()
|
||||
"""
|
||||
try:
|
||||
importlib.import_module(module_path)
|
||||
except ImportError:
|
||||
logger.error('cannot import %s', domain_name)
|
||||
domain_tree_create()
|
||||
"""
|
||||
|
||||
"""
|
||||
try:
|
||||
importlib.import_module(domain_name)
|
||||
except ImportError:
|
||||
click.echo('Error in domain creation')
|
||||
logger.debug('%s', subprocess.run(['tree', 'a', os.getcwd()]))
|
||||
raise Exception('cannot create domain {}'.format(domain_name))
|
||||
"""
|
||||
|
||||
|
||||
def create_domain():
|
||||
sys.exit(0)
|
||||
|
||||
###############
|
||||
# domain read #
|
||||
###############
|
||||
def list_routes(domain, m_dom):
|
||||
"""
|
||||
Echoes the list of the **m_dom** active routes
|
||||
"""
|
||||
def list_routes(domain):
|
||||
click.echo(f'\nDomain : {domain}')
|
||||
routers = APIRouter(domain=domain)
|
||||
for router in routers.select():
|
||||
routes = APIRoute(domain=domain, router=router['name'])
|
||||
click.echo('# /{name}'.format(**router))
|
||||
for route in routes.select():
|
||||
route.pop('fct_name')
|
||||
acls = ', '.join([ acl['acl_fct_name'] for acl in Acl(**route).select() ])
|
||||
route['acls'] = acls
|
||||
click.echo('- [{http_verb}] {path} ({acls})'.format(**route))
|
||||
|
||||
click.echo(f'\nDomain : {domain}\n')
|
||||
#################
|
||||
# domain update #
|
||||
#################
|
||||
def update_db(domain):
|
||||
|
||||
routes = api_routes(m_dom)[0]
|
||||
if len(routes):
|
||||
for key, item in routes.items():
|
||||
methods = '|'.join(list(item.keys()))
|
||||
click.echo(f'\t{key} : {methods}')
|
||||
def add_domain():
|
||||
"""
|
||||
Inserts Domain into database
|
||||
"""
|
||||
new_domain = Domain(name=domain)
|
||||
if len(new_domain) == 0:
|
||||
click.echo(f'New domain {domain}')
|
||||
new_domain.insert()
|
||||
|
||||
|
||||
def add_router(name):
|
||||
"""
|
||||
Inserts Router into database
|
||||
|
||||
Parameters:
|
||||
- name (str): The Router's name
|
||||
"""
|
||||
router = APIRouter()
|
||||
router.name = name
|
||||
router.domain = domain
|
||||
|
||||
if len(router) == 0:
|
||||
router.insert()
|
||||
|
||||
|
||||
def add_acl_fct(fct):
|
||||
"""
|
||||
Inserts ACL function into database
|
||||
|
||||
Parameters:
|
||||
- fct (Callable): The ACL function reference
|
||||
"""
|
||||
acl = AclFunction()
|
||||
acl.domain = domain
|
||||
acl.name = fct.__name__
|
||||
if len(acl) == 0:
|
||||
acl.insert()
|
||||
|
||||
|
||||
def add_acls(acls, **route):
|
||||
"""
|
||||
Inserts ACL into database
|
||||
|
||||
Parameters:
|
||||
- acls [(Callable, [str])]: List of the Route's ACL's
|
||||
- route (dict): The Route
|
||||
"""
|
||||
route.pop('fct_name')
|
||||
acl = Acl(**route)
|
||||
|
||||
for fct, keys in acls:
|
||||
acl.acl_fct_name = fct.__name__
|
||||
|
||||
if len(acl) != 0:
|
||||
raise Exception(
|
||||
'An ACL row for this route with this function already exists. Check your routers')
|
||||
else:
|
||||
click.echo('\t**No ROUTES**')
|
||||
raise Exception('Routeless domain')
|
||||
acl.keys = keys
|
||||
add_acl_fct(fct)
|
||||
acl.insert()
|
||||
|
||||
elif fct is None:
|
||||
acl.delete()
|
||||
|
||||
|
||||
|
||||
def list_api_routes():
|
||||
def get_fct_name(http_verb, path):
|
||||
"""
|
||||
Echoes the list of all active domains.
|
||||
Returns the predictable name of the function for a route
|
||||
|
||||
TODO: Rewrite function
|
||||
Parameters:
|
||||
- http_verb (str): The Route's HTTP method (GET, POST, ...)
|
||||
- path (str): A path beginning by '/' for the route
|
||||
|
||||
Returns:
|
||||
str: The *unique* function name for a route and it's verb
|
||||
|
||||
|
||||
Examples:
|
||||
|
||||
>>> get_fct_name('foo', 'bar')
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
Exception: Malformed path
|
||||
|
||||
>>> get_fct_name('get', '/')
|
||||
'get_'
|
||||
|
||||
>>> get_fct_name('GET', '/')
|
||||
'get_'
|
||||
|
||||
>>> get_fct_name('POST', '/foo')
|
||||
'post_foo'
|
||||
|
||||
>>> get_fct_name('POST', '/foo/bar')
|
||||
'post_foo_bar'
|
||||
|
||||
>>> get_fct_name('DEL', '/foo/{boo}/{far}/bar')
|
||||
'del_foo_BOO_FAR_bar'
|
||||
|
||||
>>> get_fct_name('DEL', '/foo/{boo:zoo}')
|
||||
'del_foo_BOO'
|
||||
"""
|
||||
|
||||
click.echo('# API Routes')
|
||||
# for domain, m_dom in DOMAINSDICT().items():
|
||||
# list_routes(domain, m_dom)
|
||||
if path[0] != '/':
|
||||
raise Exception('Malformed path')
|
||||
|
||||
elts = path[1:].split('/')
|
||||
|
||||
fct_name = [http_verb.lower()]
|
||||
for elt in elts:
|
||||
if elt and elt[0] == '{':
|
||||
fct_name.append(elt[1:-1].split(':')[0].upper())
|
||||
else:
|
||||
fct_name.append(elt)
|
||||
|
||||
return '_'.join(fct_name)
|
||||
|
||||
|
||||
def add_route(http_verb, path, router, acls):
|
||||
"""
|
||||
Inserts Route into database
|
||||
|
||||
Parameters:
|
||||
- http_verb (str): The Route's HTTP method (GET, POST, ...)
|
||||
- path (str): A path beginning by '/' for the route
|
||||
- router (str): The Route's Router name
|
||||
- acls (List[Callable]): The list of ACL functions for this Route
|
||||
"""
|
||||
|
||||
click.echo(f'Adding route /{domain}/{router}{path}')
|
||||
|
||||
route = APIRoute()
|
||||
# Route definition
|
||||
route.http_verb = http_verb
|
||||
route.path = path
|
||||
route.fct_name = get_fct_name(http_verb, path)
|
||||
route.router = router
|
||||
route.domain = domain
|
||||
|
||||
if len(route) == 0:
|
||||
route.insert()
|
||||
|
||||
add_acls(acls, **route.to_dict())
|
||||
|
||||
|
||||
sys.path.insert(0, BASE_DIR)
|
||||
|
||||
# Reset Domain relations
|
||||
delete_domain(domain)
|
||||
|
||||
acl_set = set()
|
||||
|
||||
try:
|
||||
# Module retrieval
|
||||
dom_mod = importlib.import_module(domain)
|
||||
except ImportError:
|
||||
# Domain is not available in current PYTHONPATH
|
||||
click.echo(f"Can't import *{domain}*", err=True)
|
||||
return False
|
||||
|
||||
try:
|
||||
add_domain()
|
||||
except Exception as e:
|
||||
# Could not insert Domain
|
||||
# @TODO : Insertion exception handling
|
||||
click.echo(e)
|
||||
click.echo(f"Could not insert *{domain}*", err=True)
|
||||
return False
|
||||
|
||||
# add sub routers
|
||||
try:
|
||||
ROUTERS = dom_mod.ROUTERS
|
||||
except AttributeError:
|
||||
# No ROUTERS variable in current domain, check domain/__init__.py
|
||||
click.echo(f'The domain {domain} has no *ROUTERS* variable', err=True)
|
||||
|
||||
for router_name in dom_mod.ROUTERS:
|
||||
try:
|
||||
router_mod = getattr(dom_mod.routers, router_name)
|
||||
except AttributError:
|
||||
# Missing router, continue
|
||||
click.echo(f'The domain {domain} has no *{router_name}* router', err=True)
|
||||
continue
|
||||
|
||||
|
||||
try:
|
||||
add_router(router_name)
|
||||
except Exception as e:
|
||||
# Could not insert Router
|
||||
# @TODO : Insertion exception handling
|
||||
print(e)
|
||||
continue
|
||||
|
||||
|
||||
for route_path, route_params in router_mod.ROUTES.items():
|
||||
for http_verb, acls in route_params.items():
|
||||
try:
|
||||
# Insert a route and it's ACLS
|
||||
add_route(http_verb, route_path, router_name, acls)
|
||||
except Exception as e:
|
||||
# Could not insert route
|
||||
# @TODO : Insertion exception handling
|
||||
print(e)
|
||||
continue
|
||||
|
||||
|
||||
#################
|
||||
# domain delete #
|
||||
#################
|
||||
def delete_domain(domain):
|
||||
d = Domain(name=domain)
|
||||
if len(d) != 1:
|
||||
return False
|
||||
|
||||
d.delete(delete_all=True)
|
||||
return True
|
||||
|
||||
|
||||
@click.option('--devel',default=None, is_flag=True)
|
||||
@click.option('--watch',default=False, is_flag=True)
|
||||
@click.option('--production',default=None, is_flag=True)
|
||||
@click.option('--port',default=None, type=int)
|
||||
@click.option('--log-level',default=None, type=str)
|
||||
@click.option('--dry-run',default=False, is_flag=True)
|
||||
@click.option('--run',default=False, is_flag=True)
|
||||
@click.option('--read',default=False, is_flag=True)
|
||||
@click.option('--conftest',default=False, is_flag=True)
|
||||
@click.option('--create',default=False, is_flag=True)
|
||||
@click.option('--update',default=False, is_flag=True)
|
||||
@click.option('--delete',default=False, is_flag=True)
|
||||
@click.argument('config_file', type=click.File(mode='rb'), required=False)
|
||||
@click.argument('domain',default=None, required=False)
|
||||
@click.option('--domains',default=None)
|
||||
@cli.command()
|
||||
def domain(domain, config_file, delete, update, create, conftest, read, run, dry_run, log_level, port, production, watch, devel):
|
||||
def domain(domains, delete, update, create, read): #, domains, read, create, update, delete):
|
||||
"""
|
||||
The "halfapi domain" command
|
||||
Lists routes for the specified domains, or update them in the database
|
||||
|
||||
Parameters:
|
||||
domain (str|None): The domain name
|
||||
domain (List[str]|None): The list of the domains to list/update
|
||||
|
||||
The parameter has a misleading name as it is a multiple option
|
||||
but this would be strange to use it several times named as "domains"
|
||||
|
||||
update (boolean): If set, update the database for the selected domains
|
||||
"""
|
||||
if not domain:
|
||||
|
||||
if not domains:
|
||||
if create:
|
||||
# TODO: Connect to the create_domain function
|
||||
raise NotImplementedError
|
||||
raise Exception('Missing domain name')
|
||||
|
||||
if config_file:
|
||||
ARG_CONFIG = toml.load(config_file.name)
|
||||
|
||||
if 'project' in ARG_CONFIG:
|
||||
for key, value in ARG_CONFIG['project'].items():
|
||||
if key in PROJECT_LEVEL_KEYS:
|
||||
CONFIG[key] = value
|
||||
|
||||
if 'domain' in ARG_CONFIG and domain in ARG_CONFIG['domain']:
|
||||
for key, value in ARG_CONFIG['domain'][domain].items():
|
||||
if key in PROJECT_LEVEL_KEYS:
|
||||
CONFIG[key] = value
|
||||
|
||||
CONFIG['domain'].update(ARG_CONFIG['domain'])
|
||||
|
||||
if create:
|
||||
raise NotImplementedError
|
||||
elif update:
|
||||
raise NotImplementedError
|
||||
elif delete:
|
||||
raise NotImplementedError
|
||||
elif read:
|
||||
from ..halfapi import HalfAPI
|
||||
|
||||
halfapi = HalfAPI(CONFIG)
|
||||
click.echo(orjson.dumps(
|
||||
halfapi.domains[domain].schema(),
|
||||
option=orjson.OPT_NON_STR_KEYS,
|
||||
default=ORJSONResponse.default_cast)
|
||||
)
|
||||
return create_domain()
|
||||
|
||||
domains = DOMAINS
|
||||
else:
|
||||
if dry_run:
|
||||
CONFIG['dryrun'] = True
|
||||
domains_ = []
|
||||
for domain_name in domains.split(','):
|
||||
if domain_name in DOMAINS:
|
||||
domains.append(domain_name)
|
||||
continue
|
||||
|
||||
domains = CONFIG.get('domain')
|
||||
for key in domains.keys():
|
||||
if key != domain:
|
||||
domains[key]['enabled'] = False
|
||||
else:
|
||||
domains[key]['enabled'] = True
|
||||
|
||||
if not log_level:
|
||||
log_level = CONFIG.get('domain', {}).get('loglevel', CONFIG.get('loglevel', False))
|
||||
else:
|
||||
CONFIG['loglevel'] = log_level
|
||||
|
||||
if not port:
|
||||
port = CONFIG.get('domain', {}).get('port', CONFIG.get('port', False))
|
||||
else:
|
||||
CONFIG['port'] = port
|
||||
|
||||
if devel is None and production is not None and (production is False or production is True):
|
||||
CONFIG['production'] = production
|
||||
|
||||
if devel is not None:
|
||||
CONFIG['production'] = False
|
||||
CONFIG['loglevel'] = 'debug'
|
||||
|
||||
|
||||
if conftest:
|
||||
click.echo(
|
||||
toml.dumps(CONFIG)
|
||||
)
|
||||
f'Domain {domain_name}s is not activated in the configuration')
|
||||
|
||||
domains = domains_
|
||||
|
||||
for domain in domains:
|
||||
if update:
|
||||
update_db(domain)
|
||||
if delete:
|
||||
delete_domain(domain)
|
||||
else:
|
||||
# domain section port is preferred, if it doesn't exist we use the global one
|
||||
list_routes(domain)
|
||||
|
||||
uvicorn_kwargs = {}
|
||||
|
||||
if CONFIG.get('port'):
|
||||
uvicorn_kwargs['port'] = CONFIG['port']
|
||||
|
||||
if CONFIG.get('loglevel'):
|
||||
uvicorn_kwargs['log_level'] = CONFIG['loglevel'].lower()
|
||||
|
||||
if watch:
|
||||
uvicorn_kwargs['reload'] = True
|
||||
|
||||
uvicorn.run(
|
||||
'halfapi.app:application',
|
||||
factory=True,
|
||||
**uvicorn_kwargs
|
||||
)
|
||||
|
||||
sys.exit(0)
|
||||
|
|
|
|||
|
|
@ -1,24 +1,19 @@
|
|||
#!/usr/bin/env python3
|
||||
"""
|
||||
cli/init.py Defines the "halfapi init" cli commands
|
||||
|
||||
Helps the user to create a new project
|
||||
"""
|
||||
# builtins
|
||||
import os
|
||||
import sys
|
||||
import re
|
||||
|
||||
import click
|
||||
import logging
|
||||
|
||||
from .. import __version__
|
||||
from ..conf import CONF_DIR
|
||||
|
||||
from halfapi import __version__
|
||||
from halfapi.cli.lib.db import ProjectDB
|
||||
from .cli import cli
|
||||
|
||||
from ..logging import logger
|
||||
logger = logging.getLogger('halfapi')
|
||||
|
||||
TMPL_HALFAPI_ETC = """[project]
|
||||
name = {project}
|
||||
host = 127.0.0.1
|
||||
port = 8000
|
||||
secret = /path/to/secret_file
|
||||
|
|
@ -26,18 +21,20 @@ production = False
|
|||
base_dir = {base_dir}
|
||||
"""
|
||||
|
||||
TMPL_HALFAPI_CONFIG = """[project]
|
||||
halfapi_version = {halfapi_version}
|
||||
def format_halfapi_etc(project, path):
|
||||
return TMPL_HALFAPI_ETC.format(
|
||||
project=project,
|
||||
base_dir=path
|
||||
)
|
||||
|
||||
[domain]
|
||||
TMPL_HALFAPI_CONFIG = """[project]
|
||||
name = {name}
|
||||
halfapi_version = {halfapi_version}
|
||||
"""
|
||||
|
||||
@click.argument('project')
|
||||
@cli.command()
|
||||
def init(project):
|
||||
"""
|
||||
The "halfapi init" command
|
||||
"""
|
||||
if not re.match('^[a-z0-9_]+$', project, re.I):
|
||||
click.echo('Project name must match "^[a-z0-9_]+$", retry.', err=True)
|
||||
sys.exit(1)
|
||||
|
|
@ -47,15 +44,28 @@ def init(project):
|
|||
sys.exit(1)
|
||||
|
||||
|
||||
logger.debug('Create directory %s', project)
|
||||
click.echo(f'create directory {project}')
|
||||
os.mkdir(project)
|
||||
|
||||
logger.debug('Create directory %s/.halfapi', project)
|
||||
os.mkdir(f'{project}/.halfapi')
|
||||
try:
|
||||
pdb = ProjectDB(project)
|
||||
pdb.init()
|
||||
except Exception as e:
|
||||
logger.warning(e)
|
||||
logger.debug(os.environ.get('HALFORM_CONF_DIR'))
|
||||
raise e
|
||||
|
||||
with open(f'{project}/.halfapi/config', 'w') as conf_file:
|
||||
conf_file.write(TMPL_HALFAPI_CONFIG.format(
|
||||
halfapi_version=__version__))
|
||||
os.mkdir(os.path.join(project, '.halfapi'))
|
||||
open(os.path.join(project, '.halfapi', 'domains'), 'w').write('[domains]\n')
|
||||
config_file = os.path.join(project, '.halfapi', 'config')
|
||||
with open(config_file, 'w') as f:
|
||||
f.write(TMPL_HALFAPI_CONFIG.format(
|
||||
name=project,
|
||||
halfapi_version=__version__
|
||||
))
|
||||
|
||||
click.echo(f'Insert this into the HALFAPI_CONF_DIR/{project} file')
|
||||
click.echo(format_halfapi_etc(
|
||||
project,
|
||||
os.path.abspath(project)))
|
||||
|
||||
click.echo(f'Configure halfapi project in {CONF_DIR}/{project}')
|
||||
|
|
|
|||
|
|
@ -0,0 +1,116 @@
|
|||
import click
|
||||
from half_orm.model import Model, CONF_DIR
|
||||
from half_orm.model_errors import MissingConfigFile
|
||||
import psycopg2
|
||||
import subprocess
|
||||
|
||||
_DB_SCHEMA = """
|
||||
create schema api;
|
||||
|
||||
create type verb as enum ('POST', 'GET', 'PUT', 'DELETE');
|
||||
|
||||
create table api.domain (
|
||||
name text,
|
||||
primary key (name)
|
||||
);
|
||||
|
||||
create table api.router (
|
||||
name text,
|
||||
domain text,
|
||||
primary key (name, domain)
|
||||
);
|
||||
|
||||
alter table api.router add constraint router_domain_fkey foreign key (domain) references api.domain(name) on update cascade on delete cascade;
|
||||
|
||||
create table api.route (
|
||||
http_verb verb,
|
||||
path text, -- relative to /<domain>/<router>
|
||||
fct_name text,
|
||||
router text,
|
||||
domain text,
|
||||
primary key (http_verb, path, router, domain)
|
||||
);
|
||||
|
||||
alter table api.route add constraint route_router_fkey foreign key (router, domain) references api.router(name, domain) on update cascade on delete cascade;
|
||||
|
||||
create table api.acl_function (
|
||||
name text,
|
||||
description text,
|
||||
domain text,
|
||||
primary key (name, domain)
|
||||
);
|
||||
|
||||
alter table api.acl_function add constraint acl_function_domain_fkey foreign key (domain) references api.domain(name) on update cascade on delete cascade;
|
||||
|
||||
create table api.acl (
|
||||
http_verb verb,
|
||||
path text not null,
|
||||
router text,
|
||||
domain text,
|
||||
acl_fct_name text,
|
||||
keys text[],
|
||||
primary key (http_verb, path, router, domain, acl_fct_name)
|
||||
);
|
||||
|
||||
alter table api.acl add constraint acl_route_fkey foreign key (http_verb, path,
|
||||
router, domain) references api.route(http_verb, path, router, domain) on update cascade on delete cascade;
|
||||
alter table api.acl add constraint acl_function_fkey foreign key (acl_fct_name, domain) references api.acl_function(name, domain) on update cascade on delete cascade;
|
||||
|
||||
create schema "api.view";
|
||||
|
||||
create view "api.view".route as
|
||||
select
|
||||
route.*,
|
||||
'/'::text || route.domain || '/'::text || route.router || route.path AS abs_path
|
||||
from
|
||||
api.route
|
||||
join api.domain on
|
||||
route.domain = domain.name
|
||||
;
|
||||
|
||||
create view "api.view".acl as
|
||||
select
|
||||
acl.*,
|
||||
'/'::text || route.domain || '/'::text || route.router || route.path AS abs_path
|
||||
from
|
||||
api.acl
|
||||
join api.acl_function on
|
||||
acl.acl_fct_name = acl_function.name
|
||||
join api.route on
|
||||
acl.domain = route.domain
|
||||
and acl.router = route.router
|
||||
and acl.path = route.path;
|
||||
"""
|
||||
|
||||
HOP_CONF = """[database]
|
||||
name = {}
|
||||
"""
|
||||
|
||||
class ProjectDB:
|
||||
def __init__(self, project_name):
|
||||
self.__project_name = project_name
|
||||
self.__db_name = f'halfapi_{self.__project_name}'
|
||||
self.__db = self._get_db()
|
||||
|
||||
def _get_db(self):
|
||||
from subprocess import PIPE
|
||||
hop_conf_file = f'{CONF_DIR}/{self.__db_name}'
|
||||
try:
|
||||
return Model(self.__db_name)
|
||||
except psycopg2.OperationalError as err:
|
||||
"créer la base de données"
|
||||
ret = subprocess.run(['/usr/bin/createdb', self.__db_name])
|
||||
if ret.returncode != 0:
|
||||
raise Exception(f"Can't create {self.__db_name}")
|
||||
except MissingConfigFile:
|
||||
print(f"demande validation de {CONF_DIR} {self.__db_name}")
|
||||
print("demande validation création de fichier de CONF")
|
||||
open(hop_conf_file, 'w').write(HOP_CONF.format(self.__db_name))
|
||||
return self._get_db()
|
||||
|
||||
def init(self):
|
||||
"""
|
||||
"""
|
||||
self.__db.execute_query(_DB_SCHEMA)
|
||||
self.__db._connection.close()
|
||||
|
||||
|
|
@ -1,54 +0,0 @@
|
|||
#!/usr/bin/env python3
|
||||
"""
|
||||
cli/routes.py Defines the "halfapi routes" cli commands
|
||||
"""
|
||||
# builtins
|
||||
import sys
|
||||
import importlib
|
||||
from pprint import pprint
|
||||
import orjson
|
||||
|
||||
import click
|
||||
|
||||
from .cli import cli
|
||||
|
||||
from ..logging import logger
|
||||
|
||||
# from ..lib.domain import domain_schema_dict
|
||||
from ..lib.constants import DOMAIN_SCHEMA, ROUTE_SCHEMA
|
||||
from ..lib.responses import ORJSONResponse
|
||||
|
||||
@click.argument('module', required=True)
|
||||
@click.option('--export', default=False, is_flag=True)
|
||||
@click.option('--validate', default=False, is_flag=True)
|
||||
@click.option('--check', default=False, is_flag=True)
|
||||
@click.option('--noheader', default=False, is_flag=True)
|
||||
@click.option('--schema', default=False, is_flag=True)
|
||||
@cli.command()
|
||||
def routes(module, export=False, validate=False, check=False, noheader=False, schema=False):
|
||||
"""
|
||||
The "halfapi routes" command
|
||||
"""
|
||||
# try:
|
||||
# mod = importlib.import_module(module)
|
||||
# except ImportError as exc:
|
||||
# raise click.BadParameter('Cannot import this module', param=module) from exc
|
||||
|
||||
# if export:
|
||||
# click.echo(schema_to_csv(module, header=not noheader))
|
||||
|
||||
# if schema:
|
||||
# routes_d = domain_schema_dict(mod)
|
||||
# ROUTE_SCHEMA.validate(routes_d)
|
||||
# click.echo(orjson.dumps(routes_d,
|
||||
# option=orjson.OPT_NON_STR_KEYS,
|
||||
# default=ORJSONResponse.default_cast))
|
||||
|
||||
|
||||
# if validate:
|
||||
# routes_d = domain_schema_dict(mod)
|
||||
# try:
|
||||
# ROUTE_SCHEMA.validate(routes_d)
|
||||
# except Exception as exc:
|
||||
# raise exc
|
||||
|
||||
|
|
@ -1,87 +1,36 @@
|
|||
#!/usr/bin/env python3
|
||||
"""
|
||||
cli/domain.py Defines the "halfapi run" cli command
|
||||
"""
|
||||
import os
|
||||
import sys
|
||||
import click
|
||||
import uvicorn
|
||||
|
||||
from .cli import cli
|
||||
from .domain import list_api_routes
|
||||
from ..conf import CONFIG, SCHEMA
|
||||
from ..logging import logger
|
||||
from ..lib.schemas import schema_csv_dict
|
||||
from ..half_domain import HalfDomain
|
||||
from halfapi.cli.domain import list_routes
|
||||
from halfapi.conf import (HOST, PORT,
|
||||
PRODUCTION, BASE_DIR, DOMAINS)
|
||||
|
||||
@click.option('--host', default=CONFIG.get('host'))
|
||||
@click.option('--port', default=CONFIG.get('port'))
|
||||
@click.option('--reload', default=False)
|
||||
@click.option('--secret', default=CONFIG.get('secret'))
|
||||
@click.option('--production', default=CONFIG.get('secret'))
|
||||
@click.option('--loglevel', default=CONFIG.get('loglevel'))
|
||||
@click.option('--prefix', default='/')
|
||||
@click.option('--check', default=True)
|
||||
@click.option('--dryrun', default=False, is_flag=True)
|
||||
@click.argument('schema', type=click.File('r'), required=False)
|
||||
@click.argument('domain', required=False)
|
||||
@click.option('--host', default=None)
|
||||
@click.option('--port', default=None)
|
||||
@cli.command()
|
||||
def run(host, port, reload, secret, production, loglevel, prefix, check, dryrun,
|
||||
schema, domain):
|
||||
"""
|
||||
The "halfapi run" command
|
||||
"""
|
||||
logger.debug('[run] host=%s port=%s reload=%s secret=%s production=%s loglevel=%s prefix=%s schema=%s',
|
||||
host, port, reload, secret, production, loglevel, prefix, schema
|
||||
)
|
||||
def run(host, port):
|
||||
|
||||
if not host:
|
||||
host = HOST
|
||||
|
||||
if not port:
|
||||
port = PORT
|
||||
|
||||
port = int(port)
|
||||
|
||||
if production and reload:
|
||||
reload = False
|
||||
raise Exception('Can\'t use live code reload in production')
|
||||
debug = reload = not PRODUCTION
|
||||
log_level = 'info' if PRODUCTION else 'debug'
|
||||
|
||||
click.echo(f'Launching application')
|
||||
click.echo('Launching application')
|
||||
|
||||
if secret:
|
||||
CONFIG['secret'] = secret
|
||||
sys.path.insert(0, BASE_DIR)
|
||||
|
||||
if schema:
|
||||
# Populate the SCHEMA global with the data from the given file
|
||||
for key, val in schema_csv_dict(schema, prefix).items():
|
||||
SCHEMA[key] = val
|
||||
|
||||
if domain:
|
||||
# If we specify a domain to run as argument
|
||||
if 'domain' not in CONFIG:
|
||||
CONFIG['domain'] = {}
|
||||
|
||||
# Disable all domains
|
||||
keys = list(CONFIG.get('domain').keys())
|
||||
for key in keys:
|
||||
CONFIG['domain'].pop(key)
|
||||
|
||||
# And activate the desired one, mounted without prefix
|
||||
CONFIG['domain'][domain] = {
|
||||
'name': domain,
|
||||
'prefix': False,
|
||||
'enabled': True
|
||||
}
|
||||
|
||||
# list_api_routes()
|
||||
|
||||
click.echo(f'uvicorn.run("halfapi.app:application"\n' \
|
||||
f'host: {host}\n' \
|
||||
f'port: {port}\n' \
|
||||
f'log_level: {loglevel}\n' \
|
||||
f'reload: {reload}\n'
|
||||
)
|
||||
|
||||
if dryrun:
|
||||
CONFIG['dryrun'] = True
|
||||
[ list_routes(domain) for domain in DOMAINS ]
|
||||
|
||||
uvicorn.run('halfapi.app:application',
|
||||
host=host,
|
||||
port=int(port),
|
||||
log_level=loglevel,
|
||||
log_level=log_level,
|
||||
reload=reload)
|
||||
|
|
|
|||
234
halfapi/conf.py
234
halfapi/conf.py
|
|
@ -1,205 +1,61 @@
|
|||
#!/usr/bin/env python3
|
||||
"""
|
||||
conf.py reads the current configuration files
|
||||
|
||||
It uses the following environment variables :
|
||||
|
||||
- HALFAPI_CONF_DIR (default: /etc/half_api)
|
||||
|
||||
|
||||
It defines the following globals :
|
||||
|
||||
- PROJECT_NAME (str) - HALFAPI_PROJECT_NAME
|
||||
- PRODUCTION (bool) - HALFAPI_PRODUCTION
|
||||
- LOGLEVEL (str) - HALFAPI_LOGLEVEL
|
||||
- BASE_DIR (str) - HALFAPI_BASE_DIR
|
||||
- HOST (str) - HALFAPI_HOST
|
||||
- PORT (int) - HALFAPI_PORT
|
||||
- CONF_DIR (str) - HALFAPI_CONF_DIR
|
||||
- DRYRUN (bool) - HALFAPI_DRYRUN
|
||||
|
||||
It reads the following ressource :
|
||||
|
||||
- ./.halfapi/config
|
||||
|
||||
It follows the following format :
|
||||
|
||||
[project]
|
||||
halfapi_version = HALFAPI_VERSION
|
||||
|
||||
[domain.domain_name]
|
||||
name = domain_name
|
||||
routers = routers
|
||||
|
||||
[domain.domain_name.config]
|
||||
option = Argh
|
||||
|
||||
"""
|
||||
|
||||
from .logging import logger
|
||||
import os
|
||||
from os import environ
|
||||
import sys
|
||||
import importlib
|
||||
import tempfile
|
||||
import uuid
|
||||
from configparser import ConfigParser
|
||||
|
||||
import toml
|
||||
IS_PROJECT = os.path.isfile('.halfapi/config')
|
||||
|
||||
SCHEMA = {}
|
||||
if IS_PROJECT:
|
||||
|
||||
DEFAULT_CONF = {
|
||||
# Default configuration values
|
||||
'SECRET': tempfile.mkstemp()[1],
|
||||
'PROJECT_NAME': os.getcwd().split('/')[-1],
|
||||
'PRODUCTION': True,
|
||||
'HOST': '127.0.0.1',
|
||||
'PORT': 3000,
|
||||
'LOGLEVEL': 'info',
|
||||
'BASE_DIR': os.getcwd(),
|
||||
'CONF_FILE': '.halfapi/config',
|
||||
'CONF_DIR': '/etc/half_api',
|
||||
'DRYRUN': None
|
||||
}
|
||||
|
||||
PROJECT_LEVEL_KEYS = {
|
||||
# Allowed keys in "project" section of configuration file
|
||||
'project_name',
|
||||
'production',
|
||||
'secret',
|
||||
'host',
|
||||
'port',
|
||||
'loglevel',
|
||||
'dryrun'
|
||||
}
|
||||
|
||||
DOMAIN_LEVEL_KEYS = PROJECT_LEVEL_KEYS | {
|
||||
# Allowed keys in "domain" section of configuration file
|
||||
'name',
|
||||
'module',
|
||||
'prefix',
|
||||
'enabled'
|
||||
}
|
||||
|
||||
CONF_FILE = os.environ.get('HALFAPI_CONF_FILE', DEFAULT_CONF['CONF_FILE'])
|
||||
CONF_DIR = os.environ.get('HALFAPI_CONF_DIR', DEFAULT_CONF['CONF_DIR'])
|
||||
|
||||
HALFAPI_ETC_FILE=os.path.join(
|
||||
CONF_DIR, 'config'
|
||||
)
|
||||
|
||||
BASE_DIR = os.environ.get('HALFAPI_BASE_DIR', DEFAULT_CONF['BASE_DIR'])
|
||||
HALFAPI_DOT_FILE=os.path.join(
|
||||
BASE_DIR, '.halfapi', 'config')
|
||||
|
||||
HALFAPI_CONFIG_FILES = []
|
||||
|
||||
try:
|
||||
with open(HALFAPI_ETC_FILE, 'r'):
|
||||
HALFAPI_CONFIG_FILES.append(HALFAPI_ETC_FILE)
|
||||
except FileNotFoundError:
|
||||
logger.info('Cannot find a configuration file under %s', HALFAPI_ETC_FILE)
|
||||
|
||||
try:
|
||||
with open(HALFAPI_DOT_FILE, 'r'):
|
||||
HALFAPI_CONFIG_FILES.append(HALFAPI_DOT_FILE)
|
||||
except FileNotFoundError:
|
||||
logger.info('Cannot find a configuration file under %s', HALFAPI_DOT_FILE)
|
||||
|
||||
|
||||
ENVIRONMENT = {}
|
||||
# Load environment variables allowed in configuration
|
||||
|
||||
if 'HALFAPI_DRYRUN' in os.environ:
|
||||
ENVIRONMENT['dryrun'] = True
|
||||
|
||||
if 'HALFAPI_PROD' in os.environ:
|
||||
ENVIRONMENT['production'] = bool(os.environ.get('HALFAPI_PROD'))
|
||||
|
||||
if 'HALFAPI_LOGLEVEL' in os.environ:
|
||||
ENVIRONMENT['loglevel'] = os.environ.get('HALFAPI_LOGLEVEL').lower()
|
||||
|
||||
if 'HALFAPI_SECRET' in os.environ:
|
||||
ENVIRONMENT['secret'] = os.environ.get('HALFAPI_SECRET')
|
||||
|
||||
if 'HALFAPI_HOST' in os.environ:
|
||||
ENVIRONMENT['host'] = os.environ.get('HALFAPI_HOST')
|
||||
|
||||
if 'HALFAPI_PORT' in os.environ:
|
||||
ENVIRONMENT['port'] = int(os.environ.get('HALFAPI_PORT'))
|
||||
|
||||
def read_config(filenames=HALFAPI_CONFIG_FILES):
|
||||
"""
|
||||
The highest index in "filenames" are the highest priorty
|
||||
"""
|
||||
d_res = {}
|
||||
|
||||
logger.info('Reading config files %s', filenames)
|
||||
for CONF_FILE in filenames:
|
||||
if os.path.isfile(CONF_FILE):
|
||||
conf_dict = toml.load(CONF_FILE)
|
||||
d_res.update(conf_dict)
|
||||
|
||||
logger.info('Read config files (result) %s', d_res)
|
||||
return { **d_res.get('project', {}), 'domain': d_res.get('domain', {}) }
|
||||
|
||||
CONFIG = read_config()
|
||||
CONFIG.update(**ENVIRONMENT)
|
||||
|
||||
PROJECT_NAME = CONFIG.get('project_name',
|
||||
os.environ.get('HALFAPI_PROJECT_NAME', DEFAULT_CONF['PROJECT_NAME']))
|
||||
|
||||
if os.environ.get('HALFAPI_DOMAIN_NAME'):
|
||||
# Force enabled domain by environment variable
|
||||
|
||||
DOMAIN_NAME = os.environ.get('HALFAPI_DOMAIN_NAME')
|
||||
if 'domain' in CONFIG and DOMAIN_NAME in CONFIG['domain'] \
|
||||
and 'config' in CONFIG['domain'][DOMAIN_NAME]:
|
||||
|
||||
domain_config = CONFIG['domain'][DOMAIN_NAME]['config']
|
||||
else:
|
||||
domain_config = {}
|
||||
|
||||
CONFIG['domain'] = {}
|
||||
|
||||
CONFIG['domain'][DOMAIN_NAME] = {
|
||||
'enabled': True,
|
||||
'name': DOMAIN_NAME,
|
||||
'prefix': False
|
||||
default_config = {
|
||||
'project': {
|
||||
'host': '127.0.0.1',
|
||||
'port': '8000',
|
||||
'secret': '',
|
||||
'base_dir': '',
|
||||
'production': 'no'
|
||||
}
|
||||
}
|
||||
|
||||
CONFIG['domain'][DOMAIN_NAME]['config'] = domain_config
|
||||
config = ConfigParser(allow_no_value=True)
|
||||
config.read_dict(default_config)
|
||||
config.read(filenames=['.halfapi/config'])
|
||||
|
||||
if os.environ.get('HALFAPI_DOMAIN_MODULE'):
|
||||
# Specify the pythonpath to import the specified domain (defaults to global)
|
||||
dom_module = os.environ.get('HALFAPI_DOMAIN_MODULE')
|
||||
CONFIG['domain'][DOMAIN_NAME]['module'] = dom_module
|
||||
PROJECT_NAME = config.get('project', 'name')
|
||||
|
||||
if len(CONFIG.get('domain', {}).keys()) == 0:
|
||||
logger.info('No domains')
|
||||
if len(PROJECT_NAME) == 0:
|
||||
raise Exception('Need a project name as argument')
|
||||
|
||||
DOMAINS = [domain for domain, _ in config.items('domains')] \
|
||||
if config.has_section('domains') \
|
||||
else []
|
||||
|
||||
# Secret
|
||||
if 'secret' not in CONFIG:
|
||||
# TODO: Create a temporary secret
|
||||
CONFIG['secret'] = DEFAULT_CONF['SECRET']
|
||||
with open(CONFIG['secret'], 'w') as secret_file:
|
||||
secret_file.write(str(uuid.uuid4()))
|
||||
CONF_DIR = environ.get('HALFAPI_CONF_DIR', '/etc/half_api')
|
||||
|
||||
try:
|
||||
with open(CONFIG['secret'], 'r') as secret_file:
|
||||
CONFIG['secret'] = CONFIG['secret'].strip()
|
||||
except FileNotFoundError as exc:
|
||||
logger.warning('Running without secret file: %s', CONFIG['secret'] or 'no file specified')
|
||||
HALFAPI_CONF_FILE=os.path.join(
|
||||
CONF_DIR,
|
||||
PROJECT_NAME
|
||||
)
|
||||
if not os.path.isfile(HALFAPI_CONF_FILE):
|
||||
print(f'Missing {HALFAPI_CONF_FILE}, exiting')
|
||||
sys.exit(1)
|
||||
config.read(filenames=[HALFAPI_CONF_FILE])
|
||||
|
||||
CONFIG.setdefault('project_name', DEFAULT_CONF['PROJECT_NAME'])
|
||||
CONFIG.setdefault('production', DEFAULT_CONF['PRODUCTION'])
|
||||
CONFIG.setdefault('host', DEFAULT_CONF['HOST'])
|
||||
CONFIG.setdefault('port', DEFAULT_CONF['PORT'])
|
||||
CONFIG.setdefault('loglevel', DEFAULT_CONF['LOGLEVEL'])
|
||||
CONFIG.setdefault('dryrun', DEFAULT_CONF['DRYRUN'])
|
||||
HOST = config.get('project', 'host')
|
||||
PORT = config.getint('project', 'port')
|
||||
DB_NAME = f'halfapi_{PROJECT_NAME}'
|
||||
|
||||
# !!!TO REMOVE!!!
|
||||
SECRET = CONFIG.get('secret')
|
||||
PRODUCTION = CONFIG.get('production')
|
||||
# !!!
|
||||
try:
|
||||
with open(config.get('project', 'secret')) as secret_file:
|
||||
SECRET = secret_file.read()
|
||||
# Set the secret so we can use it in domains
|
||||
os.environ['HALFAPI_SECRET'] = SECRET
|
||||
except FileNotFoundError:
|
||||
print('There is no file like {}'.format(config.get('project', 'secret')))
|
||||
sys.exit(1)
|
||||
|
||||
PRODUCTION = config.getboolean('project', 'production') or False
|
||||
os.environ['HALFAPI_PROD'] = str(PRODUCTION)
|
||||
|
||||
BASE_DIR = config.get('project', 'base_dir')
|
||||
|
|
|
|||
|
|
@ -0,0 +1,12 @@
|
|||
#!/usr/bin/env python3
|
||||
from halfapi.conf import DB_NAME
|
||||
|
||||
# DB
|
||||
from half_orm.model import Model
|
||||
db = Model(DB_NAME)
|
||||
Domain = db.get_relation_class('api.domain')
|
||||
APIRouter = db.get_relation_class('api.router')
|
||||
APIRoute = db.get_relation_class('api.route')
|
||||
AclFunction = db.get_relation_class('api.acl_function')
|
||||
Acl = db.get_relation_class('api.acl')
|
||||
RouteACL = db.get_relation_class('api.view.acl')
|
||||
|
|
@ -1,513 +0,0 @@
|
|||
import importlib
|
||||
import inspect
|
||||
import os
|
||||
import re
|
||||
|
||||
from packaging.specifiers import SpecifierSet
|
||||
from packaging.version import Version
|
||||
from typing import Coroutine, Dict, Iterator, List, Tuple
|
||||
from types import ModuleType, FunctionType
|
||||
|
||||
from schema import SchemaError
|
||||
|
||||
from starlette.applications import Starlette
|
||||
from starlette.middleware import Middleware
|
||||
from starlette.routing import Router, Route
|
||||
from starlette.schemas import SchemaGenerator
|
||||
|
||||
from .lib.acl import AclRoute
|
||||
from .lib.responses import ORJSONResponse
|
||||
|
||||
import yaml
|
||||
|
||||
|
||||
from . import __version__
|
||||
from .lib.constants import API_SCHEMA_DICT, ROUTER_SCHEMA, VERBS
|
||||
from .half_route import HalfRoute
|
||||
from .lib import acl as lib_acl
|
||||
from .lib.responses import PlainTextResponse
|
||||
from .lib.routes import JSONRoute
|
||||
from .lib.schemas import param_docstring_default
|
||||
from .lib.domain import MissingAclError, PathError, UnknownPathParameterType, \
|
||||
UndefinedRoute, UndefinedFunction, get_fct_name, route_decorator
|
||||
from .lib.domain_middleware import DomainMiddleware
|
||||
from .logging import logger
|
||||
|
||||
class HalfDomain(Starlette):
|
||||
def __init__(self, domain, module=None, router=None, acl=None, app=None):
|
||||
"""
|
||||
Parameters:
|
||||
domain (str): Module name (should be importable)
|
||||
router (str): Router name (should be importable from domain module
|
||||
defaults to __router__ variable from domain module)
|
||||
app (HalfAPI): The app instance
|
||||
"""
|
||||
self.app = app
|
||||
|
||||
self.m_domain = importlib.import_module(domain) if module is None else module
|
||||
self.d_domain = getattr(self.m_domain, 'domain', domain)
|
||||
self.name = self.d_domain['name']
|
||||
self.id = self.d_domain['id']
|
||||
self.version = self.d_domain['version']
|
||||
self.halfapi_version = self.d_domain.get('halfapi_version', __version__)
|
||||
self.deps = self.d_domain.get('deps', tuple())
|
||||
self.schema_components = self.d_domain.get('schema_components', dict())
|
||||
|
||||
if not router:
|
||||
self.router = self.d_domain.get('routers', '.routers')
|
||||
else:
|
||||
self.router = router
|
||||
|
||||
self.m_router = None
|
||||
try:
|
||||
self.m_router = importlib.import_module(self.router, self.m_domain.__package__)
|
||||
except AttributeError:
|
||||
raise Exception('no router module')
|
||||
|
||||
self.m_acl = HalfDomain.m_acl(self.m_domain, acl)
|
||||
|
||||
self.config = { **app.config }
|
||||
|
||||
logger.info('HalfDomain creation %s %s', domain, self.config)
|
||||
|
||||
for elt in self.deps:
|
||||
package, version = elt
|
||||
specifier = SpecifierSet(version)
|
||||
package_module = importlib.import_module(package)
|
||||
if Version(package_module.__version__) not in specifier:
|
||||
raise Exception(
|
||||
'Wrong version for package {} version {} (excepting {})'.format(
|
||||
package, package_module.__version__, specifier
|
||||
))
|
||||
|
||||
|
||||
super().__init__(
|
||||
routes=self.gen_domain_routes(),
|
||||
middleware=[
|
||||
Middleware(
|
||||
DomainMiddleware,
|
||||
domain={
|
||||
'name': self.name,
|
||||
'id': self.id,
|
||||
'version': self.version,
|
||||
'halfapi_version': self.halfapi_version,
|
||||
'config': self.config.get('domain', {}).get(self.name, {}).get('config', {})
|
||||
}
|
||||
)
|
||||
]
|
||||
)
|
||||
|
||||
@staticmethod
|
||||
def name(module):
|
||||
""" Returns the name declared in the 'domain' dict at the root of the package
|
||||
"""
|
||||
return module.domain['name']
|
||||
|
||||
|
||||
@staticmethod
|
||||
def m_acl(module, acl=None):
|
||||
""" Returns the imported acl module for the domain module
|
||||
"""
|
||||
if not acl:
|
||||
acl = getattr(module, '__acl__', '.acl')
|
||||
|
||||
return importlib.import_module(acl, module.__package__)
|
||||
|
||||
|
||||
@staticmethod
|
||||
def acls(module, acl=None):
|
||||
""" Returns the ACLS constant for the given domain
|
||||
"""
|
||||
m_acl = HalfDomain.m_acl(module, acl)
|
||||
try:
|
||||
return [
|
||||
lib_acl.ACL(*elt)
|
||||
for elt in getattr(m_acl, 'ACLS')
|
||||
]
|
||||
except AttributeError as exc:
|
||||
logger.error(exc)
|
||||
raise Exception(
|
||||
f'Missing acl.ACLS constant in module {m_acl.__package__}') from exc
|
||||
|
||||
@staticmethod
|
||||
def acls_route(domain, module_path=None, acl=None):
|
||||
""" Dictionary of acls
|
||||
|
||||
Format :
|
||||
|
||||
{
|
||||
[acl_name]: {
|
||||
callable: fct_reference,
|
||||
docs: fct_docstring,
|
||||
}
|
||||
}
|
||||
"""
|
||||
|
||||
d_res = {}
|
||||
|
||||
module = importlib.import_module(domain) \
|
||||
if module_path is None \
|
||||
else importlib.import_module(module_path)
|
||||
|
||||
m_acl = HalfDomain.m_acl(module, acl)
|
||||
|
||||
for elt in HalfDomain.acls(module, acl=acl):
|
||||
|
||||
fct = getattr(m_acl, elt.name)
|
||||
|
||||
d_res[elt.name] = {
|
||||
'callable': fct,
|
||||
'docs': elt.documentation
|
||||
}
|
||||
|
||||
return d_res
|
||||
|
||||
@staticmethod
|
||||
def acls_router(domain, module_path=None, acl=None):
|
||||
""" Returns a Router object with the following routes :
|
||||
|
||||
/ : The "acls" field of the API metadatas
|
||||
/{acl_name} : If the ACL is defined as public, a route that returns either status code 200 or 401 on HEAD/GET request
|
||||
"""
|
||||
|
||||
routes = []
|
||||
d_res = {}
|
||||
|
||||
module = importlib.import_module(domain) \
|
||||
if module_path is None \
|
||||
else importlib.import_module(module_path)
|
||||
|
||||
|
||||
m_acl = HalfDomain.m_acl(module, acl)
|
||||
|
||||
for elt in HalfDomain.acls(module, acl=acl):
|
||||
|
||||
fct = getattr(m_acl, elt.name)
|
||||
|
||||
d_res[elt.name] = {
|
||||
'callable': fct,
|
||||
'docs': elt.documentation,
|
||||
'public': elt.public
|
||||
}
|
||||
|
||||
if elt.public:
|
||||
try:
|
||||
if inspect.iscoroutinefunction(fct):
|
||||
logger.warning('async decorator are not yet supported')
|
||||
else:
|
||||
inner = fct()
|
||||
|
||||
if inspect.iscoroutinefunction(fct) or callable(inner):
|
||||
fct = inner
|
||||
|
||||
except TypeError:
|
||||
# Fct is not a decorator or is not well called (has no default arguments)
|
||||
# We can ignore this
|
||||
pass
|
||||
|
||||
routes.append(
|
||||
AclRoute(f'/{elt.name}', fct, elt)
|
||||
)
|
||||
|
||||
d_res_under_domain_name = {}
|
||||
d_res_under_domain_name[HalfDomain.name(module)] = d_res
|
||||
|
||||
routes.append(
|
||||
Route(
|
||||
'/',
|
||||
JSONRoute(d_res_under_domain_name),
|
||||
methods=['GET']
|
||||
)
|
||||
)
|
||||
|
||||
return Router(routes)
|
||||
|
||||
|
||||
@staticmethod
|
||||
def gen_routes(m_router: ModuleType,
|
||||
verb: str,
|
||||
path: List[str],
|
||||
params: List[Dict],
|
||||
path_param_docstrings: Dict[str, str] = {}) -> Tuple[FunctionType, Dict]:
|
||||
"""
|
||||
Returns a tuple of the function associatied to the verb and path arguments,
|
||||
and the dictionary of it's acls
|
||||
|
||||
Parameters:
|
||||
- m_router (ModuleType): The module containing the function definition
|
||||
|
||||
- verb (str): The HTTP verb for the route (GET, POST, ...)
|
||||
|
||||
- path (List): The route path, as a list (each item being a level of
|
||||
deepness), from the lowest level (domain) to the highest
|
||||
|
||||
- params (Dict): The acl list of the following format :
|
||||
[{'acl': Function, 'args': {'required': [], 'optional': []}}]
|
||||
|
||||
|
||||
Returns:
|
||||
|
||||
(Function, Dict): The destination function and the acl dictionary
|
||||
|
||||
"""
|
||||
if len(params) == 0:
|
||||
raise MissingAclError('[{}] {}'.format(verb, '/'.join(path)))
|
||||
|
||||
if len(path) == 0:
|
||||
logger.error('Empty path for [{%s}]', verb)
|
||||
raise PathError()
|
||||
|
||||
fct_name = get_fct_name(verb, path[-1])
|
||||
if hasattr(m_router, fct_name):
|
||||
fct = getattr(m_router, fct_name)
|
||||
fct_docstring_obj = yaml.safe_load(fct.__doc__)
|
||||
if 'parameters' not in fct_docstring_obj and path_param_docstrings:
|
||||
fct_docstring_obj['parameters'] = list(map(
|
||||
yaml.safe_load,
|
||||
path_param_docstrings.values()))
|
||||
|
||||
fct.__doc__ = yaml.dump(fct_docstring_obj)
|
||||
else:
|
||||
raise UndefinedFunction('{}.{}'.format(m_router.__name__, fct_name or ''))
|
||||
|
||||
|
||||
if not inspect.iscoroutinefunction(fct):
|
||||
return route_decorator(fct), params
|
||||
|
||||
# TODO: Remove when using only sync functions
|
||||
return lib_acl.args_check(fct), params
|
||||
|
||||
|
||||
@staticmethod
|
||||
def gen_router_routes(m_router, path: List[str], PATH_PARAMS={}) -> \
|
||||
Iterator[Tuple[str, str, ModuleType, Coroutine, List]]:
|
||||
"""
|
||||
Recursive generator that parses a router (or a subrouter)
|
||||
and yields from gen_routes
|
||||
|
||||
Parameters:
|
||||
|
||||
- m_router (ModuleType): The currently treated router module
|
||||
- path (List[str]): The current path stack
|
||||
|
||||
Yields:
|
||||
|
||||
(str, str, ModuleType, Coroutine, List): A tuple containing the path, verb,
|
||||
router module, function reference and parameters of the route.
|
||||
Function and parameters are yielded from then gen_routes function,
|
||||
that decorates the endpoint function.
|
||||
"""
|
||||
|
||||
for subpath, params in HalfDomain.read_router(m_router).items():
|
||||
path.append(subpath)
|
||||
|
||||
for verb in VERBS:
|
||||
if verb not in params:
|
||||
continue
|
||||
yield ('/'.join(filter(lambda x: len(x) > 0, path)),
|
||||
verb,
|
||||
m_router,
|
||||
*HalfDomain.gen_routes(m_router, verb, path, params[verb], PATH_PARAMS)
|
||||
)
|
||||
|
||||
for subroute in params.get('SUBROUTES', []):
|
||||
subroute_module = importlib.import_module(f'.{subroute}', m_router.__name__)
|
||||
param_match = re.fullmatch('^([A-Z_]+)_([a-z]+)$', subroute)
|
||||
parameter_name = None
|
||||
if param_match is not None:
|
||||
try:
|
||||
parameter_name = param_match.groups()[0].lower()
|
||||
if parameter_name in PATH_PARAMS:
|
||||
raise Exception(f'Duplicate parameter name in same path! {subroute} : {parameter_name}')
|
||||
|
||||
parameter_type = param_match.groups()[1]
|
||||
path.append('{{{}:{}}}'.format(
|
||||
parameter_name,
|
||||
parameter_type,
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
try:
|
||||
PATH_PARAMS[parameter_name] = subroute_module.param_docstring
|
||||
except AttributeError as exc:
|
||||
PATH_PARAMS[parameter_name] = param_docstring_default(parameter_name, parameter_type)
|
||||
|
||||
except AssertionError as exc:
|
||||
raise UnknownPathParameterType(subroute) from exc
|
||||
else:
|
||||
path.append(subroute)
|
||||
|
||||
try:
|
||||
yield from HalfDomain.gen_router_routes(
|
||||
subroute_module,
|
||||
path,
|
||||
PATH_PARAMS
|
||||
)
|
||||
|
||||
except ImportError as exc:
|
||||
logger.error('Failed to import subroute **{%s}**', subroute)
|
||||
raise exc
|
||||
|
||||
path.pop()
|
||||
if parameter_name:
|
||||
PATH_PARAMS.pop(parameter_name)
|
||||
|
||||
|
||||
path.pop()
|
||||
|
||||
|
||||
@staticmethod
|
||||
def read_router(m_router: ModuleType) -> Dict:
|
||||
"""
|
||||
Reads a module and returns a router dict
|
||||
|
||||
If the module has a "ROUTES" constant, it just returns this constant,
|
||||
Else, if the module has an "ACLS" constant, it builds the accurate dict
|
||||
|
||||
TODO: May be another thing, may be not a part of halfAPI
|
||||
|
||||
"""
|
||||
m_path = None
|
||||
|
||||
try:
|
||||
if not hasattr(m_router, 'ROUTES'):
|
||||
routes = {'':{}}
|
||||
acls = getattr(m_router, 'ACLS') if hasattr(m_router, 'ACLS') else None
|
||||
|
||||
if acls is not None:
|
||||
for method in acls.keys():
|
||||
if method not in VERBS:
|
||||
raise Exception(
|
||||
'This method is not handled: {}'.format(method))
|
||||
|
||||
routes[''][method] = []
|
||||
routes[''][method] = acls[method].copy()
|
||||
|
||||
routes['']['SUBROUTES'] = []
|
||||
if hasattr(m_router, '__path__'):
|
||||
""" Module is a package
|
||||
"""
|
||||
m_path = getattr(m_router, '__path__')
|
||||
if isinstance(m_path, list) and len(m_path) == 1:
|
||||
routes['']['SUBROUTES'] = [
|
||||
elt.name
|
||||
for elt in os.scandir(m_path[0])
|
||||
if elt.is_dir()
|
||||
]
|
||||
else:
|
||||
routes = getattr(m_router, 'ROUTES')
|
||||
|
||||
try:
|
||||
ROUTER_SCHEMA.validate(routes)
|
||||
except SchemaError as exc:
|
||||
logger.error(routes)
|
||||
raise exc
|
||||
|
||||
return routes
|
||||
except ImportError as exc:
|
||||
# TODO: Proper exception handling
|
||||
raise exc
|
||||
except FileNotFoundError as exc:
|
||||
# TODO: Proper exception handling
|
||||
logger.error(m_path)
|
||||
raise exc
|
||||
|
||||
def gen_domain_routes(self):
|
||||
"""
|
||||
Yields the Route objects for a domain
|
||||
|
||||
Parameters:
|
||||
m_domains: ModuleType
|
||||
|
||||
Returns:
|
||||
Generator(HalfRoute)
|
||||
"""
|
||||
yield HalfRoute('/',
|
||||
self.schema_openapi(),
|
||||
[{'acl': lib_acl.public}],
|
||||
'GET'
|
||||
)
|
||||
|
||||
for path, method, m_router, fct, params in HalfDomain.gen_router_routes(self.m_router, []):
|
||||
yield HalfRoute(f'/{path}', fct, params, method)
|
||||
|
||||
def schema_dict(self) -> Dict:
|
||||
""" gen_router_routes return values as a dict
|
||||
Parameters:
|
||||
|
||||
m_router (ModuleType): The domain routers' module
|
||||
|
||||
Returns:
|
||||
|
||||
Dict: Schema of dict is halfapi.lib.constants.DOMAIN_SCHEMA
|
||||
|
||||
@TODO: Should be a "router_schema_dict" function
|
||||
"""
|
||||
d_res = {}
|
||||
|
||||
for path, verb, m_router, fct, parameters in HalfDomain.gen_router_routes(self.m_router, []):
|
||||
if path not in d_res:
|
||||
d_res[path] = {}
|
||||
|
||||
if verb not in d_res[path]:
|
||||
d_res[path][verb] = {}
|
||||
|
||||
d_res[path][verb]['callable'] = f'{m_router.__name__}:{fct.__name__}'
|
||||
try:
|
||||
d_res[path][verb]['docs'] = yaml.safe_load(fct.__doc__)
|
||||
except AttributeError:
|
||||
logger.error(
|
||||
'Cannot read docstring from fct (fct=%s path=%s verb=%s', fct.__name__, path, verb)
|
||||
|
||||
d_res[path][verb]['acls'] = list(map(lambda elt: { **elt, 'acl': elt['acl'].__name__ },
|
||||
parameters))
|
||||
|
||||
return d_res
|
||||
|
||||
|
||||
def schema(self) -> Dict:
|
||||
schema = { **API_SCHEMA_DICT }
|
||||
schema['domain'] = {
|
||||
'name': self.name,
|
||||
'id': self.id,
|
||||
'version': getattr(self.m_domain, '__version__', ''),
|
||||
'patch_release': getattr(self.m_domain, '__patch_release__', ''),
|
||||
'routers': self.m_router.__name__,
|
||||
'acls': tuple(getattr(self.m_acl, 'ACLS', ()))
|
||||
}
|
||||
schema['paths'] = self.schema_dict()
|
||||
return schema
|
||||
|
||||
def schema_openapi(self) -> Route:
|
||||
schema = SchemaGenerator(
|
||||
{
|
||||
'openapi': '3.0.0',
|
||||
'info': {
|
||||
'title': self.name,
|
||||
'version': self.version,
|
||||
'x-acls': tuple(getattr(self.m_acl, 'ACLS', ())),
|
||||
**({
|
||||
f'x-{key}': value
|
||||
for key, value in self.d_domain.items()
|
||||
}),
|
||||
},
|
||||
'components': self.schema_components
|
||||
}
|
||||
|
||||
)
|
||||
|
||||
async def inner(request, *args, **kwargs):
|
||||
"""
|
||||
description: |
|
||||
Returns the current API routes description (OpenAPI v3)
|
||||
as a JSON object
|
||||
responses:
|
||||
200:
|
||||
description: API Schema in OpenAPI v3 format
|
||||
"""
|
||||
return ORJSONResponse(
|
||||
schema.get_schema(routes=request.app.routes))
|
||||
|
||||
return inner
|
||||
|
||||
|
|
@ -1,109 +0,0 @@
|
|||
""" HalfRoute
|
||||
|
||||
Child class of starlette.routing.Route
|
||||
"""
|
||||
from functools import partial, wraps
|
||||
|
||||
from typing import Callable, Coroutine, List, Dict
|
||||
from types import FunctionType
|
||||
|
||||
from starlette.requests import Request
|
||||
from starlette.responses import PlainTextResponse
|
||||
from starlette.routing import Route
|
||||
from starlette.exceptions import HTTPException
|
||||
|
||||
from .logging import logger
|
||||
from .lib.domain import MissingAclError, PathError, UnknownPathParameterType, \
|
||||
UndefinedRoute, UndefinedFunction
|
||||
|
||||
class HalfRoute(Route):
|
||||
""" HalfRoute
|
||||
"""
|
||||
def __init__(self, path: List[str], fct: Callable, params: List[Dict], method: str):
|
||||
logger.info('HalfRoute creation: %s %s %s %s', path, fct, params, method)
|
||||
if len(params) == 0:
|
||||
raise MissingAclError('[{}] {}'.format(method, '/'.join(path)))
|
||||
|
||||
if len(path) == 0:
|
||||
logger.error('Empty path for [{%s}]', method)
|
||||
raise PathError()
|
||||
|
||||
super().__init__(
|
||||
path,
|
||||
HalfRoute.acl_decorator(
|
||||
fct,
|
||||
params
|
||||
),
|
||||
methods=[method])
|
||||
|
||||
@staticmethod
|
||||
def acl_decorator(fct: Callable = None, params: List[Dict] = None) -> Coroutine:
|
||||
"""
|
||||
Decorator for async functions that calls pre-conditions functions
|
||||
and appends kwargs to the target function
|
||||
|
||||
|
||||
Parameters:
|
||||
fct (Callable):
|
||||
The function to decorate
|
||||
|
||||
params List[Dict]:
|
||||
A list of dicts that have an "acl" key that points to a function
|
||||
|
||||
Returns:
|
||||
async function
|
||||
"""
|
||||
|
||||
if not params:
|
||||
params = []
|
||||
|
||||
if not fct:
|
||||
return partial(HalfRoute.acl_decorator, params=params)
|
||||
|
||||
|
||||
@wraps(fct)
|
||||
async def caller(req: Request, *args, **kwargs):
|
||||
for param in params:
|
||||
if param.get('acl'):
|
||||
passed = param['acl'](req, *args, **kwargs)
|
||||
if isinstance(passed, FunctionType):
|
||||
passed = param['acl']()(req, *args, **kwargs)
|
||||
|
||||
if not passed:
|
||||
logger.debug(
|
||||
'ACL FAIL for current route (%s - %s)', fct, param.get('acl'))
|
||||
continue
|
||||
|
||||
logger.debug(
|
||||
'ACL OK for current route (%s - %s)', fct, param.get('acl'))
|
||||
|
||||
req.scope['acl_pass'] = param['acl'].__name__
|
||||
|
||||
if 'args' in param:
|
||||
req.scope['args'] = param['args']
|
||||
logger.debug(
|
||||
'Args for current route (%s)', param.get('args'))
|
||||
|
||||
if 'out' in param:
|
||||
req.scope['out'] = param['out']
|
||||
|
||||
if 'out' in param:
|
||||
req.scope['out'] = param['out'].copy()
|
||||
|
||||
if 'check' in req.query_params:
|
||||
return PlainTextResponse(param['acl'].__name__)
|
||||
|
||||
logger.debug('acl_decorator %s', param)
|
||||
logger.debug('calling %s:%s %s %s', fct.__module__, fct.__name__, args, kwargs)
|
||||
return await fct(
|
||||
req, *args,
|
||||
**{
|
||||
**kwargs,
|
||||
})
|
||||
|
||||
if 'check' in req.query_params:
|
||||
return PlainTextResponse('')
|
||||
|
||||
raise HTTPException(401)
|
||||
|
||||
return caller
|
||||
|
|
@ -1,316 +0,0 @@
|
|||
#!/usr/bin/env python3
|
||||
"""
|
||||
app.py is the file that is read when launching the application using an asgi
|
||||
runner.
|
||||
|
||||
It defines the following globals :
|
||||
|
||||
- routes (contains the Route objects for the application)
|
||||
- application (the asgi application itself - a starlette object)
|
||||
|
||||
"""
|
||||
import sys
|
||||
import logging
|
||||
import time
|
||||
import importlib
|
||||
from datetime import datetime
|
||||
|
||||
# asgi framework
|
||||
from starlette.applications import Starlette
|
||||
from starlette.authentication import UnauthenticatedUser
|
||||
from starlette.exceptions import HTTPException
|
||||
from starlette.middleware import Middleware
|
||||
from starlette.routing import Router, Route, Mount
|
||||
from starlette.requests import Request
|
||||
from starlette.responses import Response, PlainTextResponse
|
||||
from starlette.middleware.authentication import AuthenticationMiddleware
|
||||
|
||||
from timing_asgi import TimingMiddleware
|
||||
from timing_asgi.integrations import StarletteScopeToName
|
||||
|
||||
# module libraries
|
||||
|
||||
from .lib.constants import API_SCHEMA_DICT
|
||||
from .lib.domain_middleware import DomainMiddleware
|
||||
from .lib.timing import HTimingClient
|
||||
from .lib.jwt_middleware import JWTAuthenticationBackend, on_auth_error
|
||||
from .lib.responses import (ORJSONResponse, UnauthorizedResponse,
|
||||
NotFoundResponse, InternalServerErrorResponse, NotImplementedResponse,
|
||||
ServiceUnavailableResponse, gen_exception_route)
|
||||
from .lib.domain import NoDomainsException
|
||||
from .lib.routes import gen_schema_routes, JSONRoute
|
||||
from .lib.schemas import schema_json
|
||||
from .logging import logger, config_logging
|
||||
from .half_domain import HalfDomain
|
||||
from halfapi import __version__
|
||||
|
||||
class HalfAPI(Starlette):
|
||||
def __init__(self,
|
||||
config,
|
||||
d_routes=None):
|
||||
# Set log level (defaults to debug)
|
||||
config_logging(
|
||||
getattr(logging, config.get('loglevel', 'DEBUG').upper(), 'DEBUG')
|
||||
)
|
||||
self.config = config
|
||||
SECRET = self.config.get('secret')
|
||||
PRODUCTION = self.config.get('production', True)
|
||||
DRYRUN = self.config.get('dryrun', False)
|
||||
TIMINGMIDDLEWARE = self.config.get('timingmiddleware', False)
|
||||
|
||||
if DRYRUN:
|
||||
logger.info('HalfAPI starting in dry-run mode')
|
||||
else:
|
||||
logger.info('HalfAPI starting')
|
||||
|
||||
|
||||
self.PRODUCTION = PRODUCTION
|
||||
self.SECRET = SECRET
|
||||
|
||||
# Domains
|
||||
|
||||
""" HalfAPI routes (if not PRODUCTION, includes debug routes)
|
||||
"""
|
||||
routes = []
|
||||
routes.append(
|
||||
Mount('/halfapi', routes=list(self.halfapi_routes()))
|
||||
)
|
||||
|
||||
logger.debug('Config: %s', self.config)
|
||||
|
||||
domains = {
|
||||
key: elt
|
||||
for key, elt in self.config.get('domain', {}).items()
|
||||
if elt.get('enabled', False)
|
||||
}
|
||||
|
||||
logger.debug('Active domains: %s', domains)
|
||||
|
||||
if d_routes:
|
||||
# Mount the routes from the d_routes argument - domain-less mode
|
||||
logger.info('Domain-less mode : the given schema defines the activated routes')
|
||||
for route in gen_schema_routes(d_routes):
|
||||
routes.append(route)
|
||||
else:
|
||||
pass
|
||||
|
||||
startup_fcts = []
|
||||
|
||||
if DRYRUN:
|
||||
startup_fcts.append(
|
||||
HalfAPI.wait_quit()
|
||||
)
|
||||
|
||||
super().__init__(
|
||||
debug=not PRODUCTION,
|
||||
routes=routes,
|
||||
exception_handlers={
|
||||
401: gen_exception_route(UnauthorizedResponse),
|
||||
404: gen_exception_route(NotFoundResponse),
|
||||
500: gen_exception_route(HalfAPI.exception),
|
||||
501: gen_exception_route(NotImplementedResponse),
|
||||
503: gen_exception_route(ServiceUnavailableResponse)
|
||||
}
|
||||
)
|
||||
|
||||
schemas = []
|
||||
|
||||
self.__domains = {}
|
||||
|
||||
for key, domain in domains.items():
|
||||
if not isinstance(domain, dict):
|
||||
continue
|
||||
|
||||
dom_name = domain.get('name', key)
|
||||
if not domain.get('enabled', False):
|
||||
continue
|
||||
|
||||
if not domain.get('prefix', False):
|
||||
if len(domains.keys()) > 1:
|
||||
raise Exception('Cannot use multiple domains and set prefix to false')
|
||||
path = '/'
|
||||
else:
|
||||
path = f'/{dom_name}'
|
||||
|
||||
logger.debug('Mounting domain %s on %s', domain.get('name'), path)
|
||||
|
||||
domain_key = domain.get('name', key)
|
||||
|
||||
add_domain_args = {
|
||||
**domain,
|
||||
'path': path
|
||||
}
|
||||
|
||||
self.add_domain(**add_domain_args)
|
||||
|
||||
schemas.append(self.__domains[domain_key].schema())
|
||||
|
||||
|
||||
self.add_route('/', JSONRoute(schemas))
|
||||
|
||||
if SECRET:
|
||||
self.add_middleware(
|
||||
AuthenticationMiddleware,
|
||||
backend=JWTAuthenticationBackend(),
|
||||
on_error=on_auth_error
|
||||
)
|
||||
|
||||
if not PRODUCTION and TIMINGMIDDLEWARE:
|
||||
self.add_middleware(
|
||||
TimingMiddleware,
|
||||
client=HTimingClient(),
|
||||
metric_namer=StarletteScopeToName(prefix="halfapi",
|
||||
starlette_app=self)
|
||||
)
|
||||
|
||||
@property
|
||||
def version(self):
|
||||
return __version__
|
||||
|
||||
async def version_async(self, request, *args, **kwargs):
|
||||
"""
|
||||
description: Version route
|
||||
responses:
|
||||
200:
|
||||
description: Currently running HalfAPI's version
|
||||
"""
|
||||
return Response(self.version)
|
||||
|
||||
@staticmethod
|
||||
async def exception(request: Request, exc: HTTPException):
|
||||
logger.critical(exc, exc_info=True)
|
||||
return InternalServerErrorResponse()
|
||||
|
||||
@property
|
||||
def application(self):
|
||||
return self
|
||||
|
||||
def halfapi_routes(self):
|
||||
""" Halfapi default routes
|
||||
"""
|
||||
|
||||
async def get_user(request, *args, **kwargs):
|
||||
"""
|
||||
description: WhoAmI route
|
||||
responses:
|
||||
200:
|
||||
description: The currently logged-in user
|
||||
content:
|
||||
application/json:
|
||||
schema:
|
||||
type: object
|
||||
"""
|
||||
return ORJSONResponse({'user':request.user})
|
||||
|
||||
yield Route('/whoami', get_user)
|
||||
yield Route('/schema', schema_json)
|
||||
yield Mount('/acls', self.acls_router())
|
||||
yield Route('/version', self.version_async)
|
||||
""" Halfapi debug routes definition
|
||||
"""
|
||||
if self.PRODUCTION:
|
||||
return
|
||||
|
||||
""" Debug routes
|
||||
"""
|
||||
async def debug_log(request: Request, *args, **kwargs):
|
||||
logger.debug('debuglog# %s', {datetime.now().isoformat()})
|
||||
logger.info('debuglog# %s', {datetime.now().isoformat()})
|
||||
logger.warning('debuglog# %s', {datetime.now().isoformat()})
|
||||
logger.error('debuglog# %s', {datetime.now().isoformat()})
|
||||
logger.critical('debuglog# %s', {datetime.now().isoformat()})
|
||||
return Response('')
|
||||
yield Route('/log', debug_log)
|
||||
|
||||
async def error_code(request: Request, *args, **kwargs):
|
||||
code = request.path_params['code']
|
||||
raise HTTPException(code)
|
||||
|
||||
yield Route('/error/{code:int}', error_code)
|
||||
|
||||
async def exception(request: Request, *args, **kwargs):
|
||||
raise Exception('Test exception')
|
||||
|
||||
yield Route('/exception', exception)
|
||||
|
||||
@staticmethod
|
||||
def api_schema(domain):
|
||||
pass
|
||||
|
||||
@staticmethod
|
||||
def wait_quit():
|
||||
""" sleeps 1 second and quits. used in dry-run mode
|
||||
"""
|
||||
import time
|
||||
import sys
|
||||
time.sleep(1)
|
||||
sys.exit(0)
|
||||
|
||||
def acls_router(self):
|
||||
mounts = {}
|
||||
|
||||
for domain, domain_conf in self.config.get('domain', {}).items():
|
||||
if isinstance(domain_conf, dict) and domain_conf.get('enabled', False):
|
||||
mounts['domain'] = HalfDomain.acls_router(
|
||||
domain,
|
||||
module_path=domain_conf.get('module'),
|
||||
acl=domain_conf.get('acl')
|
||||
)
|
||||
|
||||
if len(mounts) > 1:
|
||||
return Router([
|
||||
Mount(f'/{domain}', acls_router)
|
||||
for domain, acls_router in mounts.items()
|
||||
])
|
||||
elif len(mounts) == 1:
|
||||
return Mount('/', mounts.popitem()[1])
|
||||
else:
|
||||
return Router()
|
||||
|
||||
@property
|
||||
def domains(self):
|
||||
return self.__domains
|
||||
|
||||
def add_domain(self, **kwargs):
|
||||
|
||||
if not kwargs.get('enabled'):
|
||||
raise Exception(f'Domain not enabled ({kwargs})')
|
||||
|
||||
name = kwargs['name']
|
||||
|
||||
self.config['domain'][name] = kwargs.get('config', {})
|
||||
|
||||
if not kwargs.get('module'):
|
||||
module = name
|
||||
else:
|
||||
module = kwargs.get('module')
|
||||
|
||||
try:
|
||||
self.__domains[name] = HalfDomain(
|
||||
name,
|
||||
module=importlib.import_module(module),
|
||||
router=kwargs.get('router'),
|
||||
acl=kwargs.get('acl'),
|
||||
app=self
|
||||
)
|
||||
|
||||
except ImportError as exc:
|
||||
print(
|
||||
'Cannot instantiate HalfDomain {} with module {}'.format(
|
||||
name,
|
||||
module
|
||||
))
|
||||
raise exc
|
||||
|
||||
self.mount(kwargs.get('path', name), self.__domains[name])
|
||||
|
||||
return self.__domains[name]
|
||||
|
||||
|
||||
def __main__():
|
||||
return HalfAPI(CONFIG).application
|
||||
|
||||
if __name__ == '__main__':
|
||||
__main__()
|
||||
|
||||
|
||||
|
|
@ -1,178 +1,24 @@
|
|||
#!/usr/bin/env python3
|
||||
"""
|
||||
Base ACL module that contains generic functions for domains ACL
|
||||
"""
|
||||
from dataclasses import dataclass
|
||||
from functools import wraps
|
||||
from json import JSONDecodeError
|
||||
import yaml
|
||||
from starlette.authentication import UnauthenticatedUser
|
||||
from starlette.exceptions import HTTPException
|
||||
from starlette.routing import Route
|
||||
from starlette.responses import Response
|
||||
|
||||
from ..logging import logger
|
||||
""" Base ACL module that contains generic functions for domains ACL
|
||||
"""
|
||||
|
||||
def connected(func):
|
||||
""" Decorator that checks if the user object of the request has been set
|
||||
"""
|
||||
@wraps(func)
|
||||
def caller(req, *args, **kwargs):
|
||||
if (not hasattr(req, 'user')
|
||||
or type(req.user) == UnauthenticatedUser
|
||||
or not hasattr(req.user, 'is_authenticated')):
|
||||
return False
|
||||
|
||||
return func(req, **{**kwargs, **req.path_params})
|
||||
|
||||
return caller
|
||||
|
||||
def public(*args, **kwargs) -> bool:
|
||||
"Unlimited access"
|
||||
return True
|
||||
|
||||
def private(*args, **kwargs) -> bool:
|
||||
"Forbidden access"
|
||||
return False
|
||||
|
||||
|
||||
def connected(fct=public):
|
||||
""" Decorator that checks if the user object of the request has been set
|
||||
"""
|
||||
@wraps(fct)
|
||||
def caller(req, *args, **kwargs):
|
||||
if (not hasattr(req, 'user')
|
||||
or isinstance(req.user, UnauthenticatedUser)
|
||||
or not hasattr(req.user, 'is_authenticated')):
|
||||
return False
|
||||
|
||||
if hasattr(req, 'path_params'):
|
||||
return fct(req, **{**kwargs, **req.path_params})
|
||||
return fct(req, **{**kwargs})
|
||||
|
||||
return caller
|
||||
|
||||
def args_check(fct):
|
||||
""" Decorator that puts required and optional arguments in scope
|
||||
|
||||
For GET requests it uses the query_params
|
||||
|
||||
For POST requests it uses the body as JSON
|
||||
|
||||
If "check" is present in the query params, nothing is done.
|
||||
|
||||
If some required arguments are missing, a 400 status code is sent.
|
||||
"""
|
||||
@wraps(fct)
|
||||
async def caller(req, *args, **kwargs):
|
||||
if 'check' in req.query_params:
|
||||
# Check query param should not read the "args"
|
||||
return await fct(req, *args, **kwargs)
|
||||
|
||||
data_ = {}
|
||||
if req.method == 'GET':
|
||||
data_ = dict(req.query_params)
|
||||
|
||||
elif req.method in ['POST', 'PATCH', 'PUT', 'DELETE']:
|
||||
if req.scope.get('headers'):
|
||||
if b'content-type' not in dict(req.scope.get('headers')):
|
||||
data_ = {}
|
||||
else:
|
||||
content_type = dict(req.scope.get('headers')).get(b'content-type').decode().split(';')[0]
|
||||
|
||||
if content_type == 'application/json':
|
||||
try:
|
||||
data_ = await req.json()
|
||||
except JSONDecodeError as exc:
|
||||
logger.debug('Posted data was not JSON')
|
||||
pass
|
||||
elif content_type in [
|
||||
'multipart/form-data', 'application/x-www-form-urlencoded']:
|
||||
data_ = dict(await req.form())
|
||||
else:
|
||||
data_ = await req.body()
|
||||
|
||||
def plural(array: list) -> str:
|
||||
return 's' if len(array) > 1 else ''
|
||||
def comma_list(array: list) -> str:
|
||||
return ', '.join(array)
|
||||
|
||||
|
||||
args_d = req.scope.get('args')
|
||||
if args_d is not None and isinstance(data_, dict):
|
||||
required = args_d.get('required', set())
|
||||
|
||||
missing = []
|
||||
data = {}
|
||||
|
||||
for key in required:
|
||||
data[key] = data_.get(key, None)
|
||||
if data[key] is None:
|
||||
missing.append(key)
|
||||
|
||||
if missing:
|
||||
raise HTTPException(
|
||||
400,
|
||||
f"Missing value{plural(missing)} for: {comma_list(missing)}!")
|
||||
|
||||
optional = args_d.get('optional', set())
|
||||
for key in optional:
|
||||
if key in data_:
|
||||
data[key] = data_[key]
|
||||
else:
|
||||
""" Unsafe mode, without specified arguments, or plain text mode
|
||||
"""
|
||||
data = data_
|
||||
|
||||
kwargs['data'] = data
|
||||
|
||||
out_s = req.scope.get('out')
|
||||
if out_s:
|
||||
kwargs['out'] = list(out_s)
|
||||
|
||||
return await fct(req, *args, **kwargs)
|
||||
|
||||
return caller
|
||||
|
||||
# ACLS list for doc and priorities
|
||||
# Write your own constant in your domain or import this one
|
||||
# Format : (acl_name: str, acl_documentation: str, priority: int, [public=False])
|
||||
#
|
||||
# The 'priority' integer is greater than zero and the lower values means more
|
||||
# priority. For a route, the order of declaration of the ACLs should respect
|
||||
# their priority.
|
||||
#
|
||||
# When the 'public' boolean value is True, a route protected by this ACL is
|
||||
# defined on the "/halfapi/acls/acl_name", that returns an empty response and
|
||||
# the status code 200 or 401.
|
||||
|
||||
ACLS = (
|
||||
('private', private.__doc__, 0, True),
|
||||
('public', public.__doc__, 999, True)
|
||||
)
|
||||
|
||||
@dataclass
|
||||
class ACL():
|
||||
name: str
|
||||
documentation: str
|
||||
priority: int
|
||||
public: bool = False
|
||||
|
||||
|
||||
class AclRoute(Route):
|
||||
def __init__(self, path, acl_fct, acl: ACL):
|
||||
self.acl_fct = acl_fct
|
||||
self.name = acl.name
|
||||
self.description = acl.documentation
|
||||
|
||||
self.docstring = yaml.dump({
|
||||
'description': f'{self.name}: {self.description}',
|
||||
'responses': {
|
||||
'200': {
|
||||
'description': 'ACL OK'
|
||||
},
|
||||
'401': {
|
||||
'description': 'ACL FAIL'
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
async def endpoint(request, *args, **kwargs):
|
||||
if request.method == 'GET':
|
||||
logger.warning('Deprecated since 0.6.28, use HEAD method since now')
|
||||
|
||||
if self.acl_fct(request, *args, **kwargs) is True:
|
||||
return Response(status_code=200)
|
||||
|
||||
return Response(status_code=401)
|
||||
|
||||
endpoint.__doc__ = self.docstring
|
||||
|
||||
return super().__init__(path, methods=['HEAD', 'GET'], endpoint=endpoint)
|
||||
|
||||
|
|
|
|||
|
|
@ -1,71 +0,0 @@
|
|||
import re
|
||||
from schema import Schema, Optional, Or
|
||||
from .. import __version__
|
||||
|
||||
VERBS = ('GET', 'POST', 'PUT', 'PATCH', 'DELETE')
|
||||
|
||||
ITERABLE_STR = Or([ str ], { str }, ( str ))
|
||||
|
||||
ACLS_SCHEMA = Schema([{
|
||||
'acl': str,
|
||||
Optional('args'): {
|
||||
Optional('required'): ITERABLE_STR,
|
||||
Optional('optional'): ITERABLE_STR
|
||||
},
|
||||
Optional('out'): ITERABLE_STR
|
||||
}])
|
||||
ROUTER_ACLS_SCHEMA = Schema([{
|
||||
'acl': lambda n: callable(n),
|
||||
Optional('args'): {
|
||||
Optional('required'): ITERABLE_STR,
|
||||
Optional('optional'): ITERABLE_STR
|
||||
},
|
||||
Optional('out'): ITERABLE_STR
|
||||
}])
|
||||
|
||||
|
||||
is_callable_dotted_notation = lambda x: re.match(
|
||||
r'^(([a-zA-Z_])+\.?)*:[a-zA-Z_]+$', 'ab_c.TEST:get')
|
||||
|
||||
ROUTE_SCHEMA = Schema({
|
||||
Optional(str): { # path - Optional when no routes
|
||||
str: { # method
|
||||
'callable': is_callable_dotted_notation,
|
||||
'docs': lambda n: True, # Should validate an openAPI spec
|
||||
'acls': ACLS_SCHEMA
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
DOMAIN_SCHEMA = Schema({
|
||||
'name': str,
|
||||
'id': str,
|
||||
Optional('routers'): str,
|
||||
Optional('version'): str,
|
||||
Optional('patch_release'): str,
|
||||
Optional('acls'): [
|
||||
[str, str, int, Optional(bool)]
|
||||
]
|
||||
})
|
||||
|
||||
API_SCHEMA_DICT = {
|
||||
'openapi': '3.0.0',
|
||||
'info': {
|
||||
'title': 'HalfAPI',
|
||||
'version': __version__
|
||||
},
|
||||
}
|
||||
|
||||
API_SCHEMA = Schema({
|
||||
**API_SCHEMA_DICT,
|
||||
'domain': DOMAIN_SCHEMA,
|
||||
'paths': ROUTE_SCHEMA
|
||||
})
|
||||
|
||||
ROUTER_SCHEMA = Schema({
|
||||
Or('', str): {
|
||||
# Optional('GET'): [],#ACLS_SCHEMA,
|
||||
Optional(Or(*VERBS)): ROUTER_ACLS_SCHEMA,
|
||||
Optional('SUBROUTES'): [Optional(str)]
|
||||
}
|
||||
})
|
||||
|
|
@ -1,192 +0,0 @@
|
|||
#!/usr/bin/env python3
|
||||
"""
|
||||
lib/domain.py The domain-scoped utility functions
|
||||
"""
|
||||
|
||||
import re
|
||||
import sys
|
||||
import importlib
|
||||
import inspect
|
||||
from functools import wraps
|
||||
from types import ModuleType, FunctionType
|
||||
from typing import Coroutine, Generator
|
||||
from typing import Dict, List, Tuple
|
||||
import yaml
|
||||
|
||||
from starlette.exceptions import HTTPException
|
||||
|
||||
from halfapi.lib import acl
|
||||
from halfapi.lib.responses import ORJSONResponse, ODSResponse, XLSXResponse, PlainTextResponse, HTMLResponse
|
||||
# from halfapi.lib.router import read_router
|
||||
from halfapi.lib.constants import VERBS
|
||||
|
||||
from ..logging import logger
|
||||
|
||||
class MissingAclError(Exception):
|
||||
""" Exception to use when no acl are specified for a route
|
||||
"""
|
||||
pass
|
||||
|
||||
class PathError(Exception):
|
||||
""" Exception to use when the path for a route is malformed
|
||||
"""
|
||||
pass
|
||||
|
||||
class UnknownPathParameterType(Exception):
|
||||
""" Exception to use when the path parameter for a route is not supported
|
||||
"""
|
||||
pass
|
||||
|
||||
class UndefinedRoute(Exception):
|
||||
""" Exception to use when the route definition cannot be found
|
||||
"""
|
||||
pass
|
||||
|
||||
class UndefinedFunction(Exception):
|
||||
""" Exception to use when a function definition cannot be found
|
||||
"""
|
||||
pass
|
||||
|
||||
class NoDomainsException(Exception):
|
||||
""" The exception that is raised when HalfAPI is called without domains
|
||||
"""
|
||||
pass
|
||||
|
||||
def route_decorator(fct: FunctionType) -> Coroutine:
|
||||
""" Returns an async function that can be mounted on a router
|
||||
"""
|
||||
@wraps(fct)
|
||||
@acl.args_check
|
||||
async def wrapped(request, *args, **kwargs):
|
||||
fct_args_spec = inspect.getfullargspec(fct).args
|
||||
fct_args_defaults = inspect.getfullargspec(fct).defaults or []
|
||||
fct_args_defaults_dict = dict(list(zip(
|
||||
reversed(fct_args_spec),
|
||||
reversed(fct_args_defaults)
|
||||
)))
|
||||
|
||||
fct_args = request.path_params.copy()
|
||||
|
||||
if 'halfapi' in fct_args_spec:
|
||||
fct_args['halfapi'] = {
|
||||
'user': request.user if
|
||||
'user' in request else None,
|
||||
'config': request.scope.get('config', {}),
|
||||
'domain': request.scope.get('domain', 'unknown'),
|
||||
'cookies': request.cookies,
|
||||
'base_url': request.base_url,
|
||||
'url': request.url
|
||||
}
|
||||
|
||||
if 'data' in fct_args_spec:
|
||||
if 'data' in fct_args_defaults_dict:
|
||||
fct_args['data'] = fct_args_defaults_dict['data']
|
||||
else:
|
||||
fct_args['data'] = {}
|
||||
|
||||
fct_args['data'].update(kwargs.get('data', {}))
|
||||
|
||||
if 'out' in fct_args_spec:
|
||||
fct_args['out'] = kwargs.get('out')
|
||||
|
||||
""" If format argument is specified (either by get, post param or function argument)
|
||||
"""
|
||||
if 'ret_type' in fct_args_defaults_dict:
|
||||
ret_type = fct_args_defaults_dict['ret_type']
|
||||
else:
|
||||
ret_type = fct_args.get('data', {}).get('format', 'json')
|
||||
|
||||
logger.debug('Return type {} (defaults: {})'.format(ret_type,
|
||||
fct_args_defaults_dict))
|
||||
try:
|
||||
logger.debug('FCT_ARGS***** %s', fct_args)
|
||||
if ret_type == 'json':
|
||||
return ORJSONResponse(fct(**fct_args))
|
||||
|
||||
if ret_type == 'ods':
|
||||
res = fct(**fct_args)
|
||||
assert isinstance(res, list)
|
||||
for elt in res:
|
||||
assert isinstance(elt, dict)
|
||||
|
||||
return ODSResponse(res)
|
||||
|
||||
if ret_type == 'xlsx':
|
||||
res = fct(**fct_args)
|
||||
assert isinstance(res, list)
|
||||
for elt in res:
|
||||
assert isinstance(elt, dict)
|
||||
|
||||
return XLSXResponse(res)
|
||||
|
||||
if ret_type in ['html', 'xhtml']:
|
||||
res = fct(**fct_args)
|
||||
assert isinstance(res, str)
|
||||
|
||||
return HTMLResponse(res)
|
||||
|
||||
if ret_type in 'txt':
|
||||
res = fct(**fct_args)
|
||||
assert isinstance(res, str)
|
||||
|
||||
return PlainTextResponse(res)
|
||||
|
||||
|
||||
raise NotImplementedError
|
||||
|
||||
except NotImplementedError as exc:
|
||||
raise HTTPException(501) from exc
|
||||
except Exception as exc:
|
||||
# TODO: Write tests
|
||||
logger.error(exc, exc_info=True)
|
||||
if not isinstance(exc, HTTPException):
|
||||
raise HTTPException(500) from exc
|
||||
raise exc
|
||||
|
||||
return wrapped
|
||||
|
||||
|
||||
def get_fct_name(http_verb: str, path: str) -> str:
|
||||
"""
|
||||
Returns the predictable name of the function for a route
|
||||
|
||||
Parameters:
|
||||
- http_verb (str): The Route's HTTP method (GET, POST, ...)
|
||||
- path (str): The functions path
|
||||
|
||||
Returns:
|
||||
str: The *unique* function name for a route and it's verb
|
||||
|
||||
|
||||
Examples:
|
||||
|
||||
>>> get_fct_name('get', '')
|
||||
'get'
|
||||
|
||||
>>> get_fct_name('GET', '')
|
||||
'get'
|
||||
|
||||
>>> get_fct_name('POST', 'foo')
|
||||
'post_foo'
|
||||
|
||||
>>> get_fct_name('POST', 'bar')
|
||||
'post_bar'
|
||||
|
||||
>>> get_fct_name('DEL', 'foo/{boo}')
|
||||
'del_foo_BOO'
|
||||
|
||||
>>> get_fct_name('DEL', '{boo:zoo}/far')
|
||||
'del_BOO_far'
|
||||
"""
|
||||
if path and path[0] == '/':
|
||||
path = path[1:]
|
||||
|
||||
fct_name = [http_verb.lower()]
|
||||
for elt in path.split('/'):
|
||||
if elt and elt[0] == '{':
|
||||
fct_name.append(elt[1:-1].split(':')[0].upper())
|
||||
elif elt:
|
||||
fct_name.append(elt)
|
||||
|
||||
return '_'.join(fct_name)
|
||||
|
||||
|
|
@ -1,80 +0,0 @@
|
|||
"""
|
||||
DomainMiddleware
|
||||
"""
|
||||
from starlette.datastructures import URL
|
||||
from starlette.middleware.base import (BaseHTTPMiddleware,
|
||||
RequestResponseEndpoint)
|
||||
from starlette.requests import Request
|
||||
from starlette.responses import Response
|
||||
|
||||
from ..logging import logger
|
||||
|
||||
class DomainMiddleware(BaseHTTPMiddleware):
|
||||
"""
|
||||
DomainMiddleware adds the api routes and acls to the following scope keys :
|
||||
|
||||
- api
|
||||
- acl
|
||||
"""
|
||||
|
||||
def __init__(self, app, domain=None):
|
||||
""" app: HalfAPI instance
|
||||
"""
|
||||
logger.info('DomainMiddleware app:%s domain:%s', app, domain)
|
||||
super().__init__(app)
|
||||
self.domain = domain
|
||||
self.request = None
|
||||
|
||||
|
||||
async def dispatch(self, request: Request,
|
||||
call_next: RequestResponseEndpoint) -> Response:
|
||||
"""
|
||||
Call of the route fonction (decorated or not)
|
||||
"""
|
||||
|
||||
request.scope['domain'] = self.domain['name']
|
||||
if hasattr(request.app, 'config') \
|
||||
and isinstance(request.app.config, dict):
|
||||
# Set the config scope to the domain's config
|
||||
request.scope['config'] = request.app.config.get(
|
||||
'domain', {}
|
||||
).get(
|
||||
self.domain['name'], {}
|
||||
).copy()
|
||||
|
||||
# TODO: Remove in 0.7.0
|
||||
config = request.scope['config'].copy()
|
||||
request.scope['config']['domain'] = {}
|
||||
request.scope['config']['domain'][self.domain['name']] = {}
|
||||
request.scope['config']['domain'][self.domain['name']]['config'] = config
|
||||
|
||||
|
||||
|
||||
else:
|
||||
logger.debug('%s', request.app)
|
||||
logger.debug('%s', getattr(request.app, 'config', None))
|
||||
|
||||
response = await call_next(request)
|
||||
|
||||
if 'acl_pass' in request.scope:
|
||||
# Set the http header "x-acl" if an acl was used on the route
|
||||
response.headers['x-acl'] = request.scope['acl_pass']
|
||||
|
||||
if 'args' in request.scope:
|
||||
# Set the http headers "x-args-required" and "x-args-optional"
|
||||
|
||||
if len(request.scope['args'].get('required', set())):
|
||||
response.headers['x-args-required'] = \
|
||||
','.join(request.scope['args']['required'])
|
||||
if len(request.scope['args'].get('optional', set())):
|
||||
response.headers['x-args-optional'] = \
|
||||
','.join(request.scope['args']['optional'])
|
||||
|
||||
if len(request.scope.get('out', set())):
|
||||
response.headers['x-out'] = \
|
||||
','.join(request.scope['out'])
|
||||
|
||||
|
||||
response.headers['x-domain'] = self.domain['name']
|
||||
|
||||
return response
|
||||
|
|
@ -1,54 +1,89 @@
|
|||
"""
|
||||
JWT Middleware module
|
||||
__LICENSE__ = """
|
||||
BSD 3-Clause License
|
||||
|
||||
Classes:
|
||||
- JWTUser : goes in request.user
|
||||
- JWTAuthenticationBackend
|
||||
- JWTWebSocketAuthenticationBackend
|
||||
Copyright (c) 2018, Amit Ripshtos
|
||||
All rights reserved.
|
||||
|
||||
Raises:
|
||||
Exception: If configuration has no SECRET
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
* Redistributions of source code must retain the above copyright notice, this
|
||||
list of conditions and the following disclaimer.
|
||||
|
||||
* Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
* Neither the name of the copyright holder nor the names of its
|
||||
contributors may be used to endorse or promote products derived from
|
||||
this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
|
||||
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
||||
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
||||
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
"""
|
||||
|
||||
from os import environ
|
||||
import typing
|
||||
from uuid import UUID
|
||||
|
||||
from http.cookies import SimpleCookie
|
||||
import jwt
|
||||
from uuid import UUID
|
||||
from starlette.authentication import (
|
||||
AuthenticationBackend, AuthenticationError, BaseUser, AuthCredentials,
|
||||
UnauthenticatedUser)
|
||||
from starlette.requests import HTTPConnection, Request
|
||||
from starlette.exceptions import HTTPException
|
||||
|
||||
from .user import CheckUser, JWTUser, Nobody
|
||||
from ..logging import logger
|
||||
from ..conf import CONFIG
|
||||
from ..lib.responses import ORJSONResponse
|
||||
|
||||
SECRET=None
|
||||
import logging
|
||||
logger = logging.getLogger('halfapi')
|
||||
|
||||
try:
|
||||
with open(CONFIG.get('secret', ''), 'r') as secret_file:
|
||||
SECRET = secret_file.read().strip()
|
||||
except FileNotFoundError:
|
||||
logger.error('Could not import SECRET variable from conf module,'\
|
||||
from ..conf import PRODUCTION
|
||||
except ImportError:
|
||||
logger.warning('Could not import PRODUCTION variable from conf module,'\
|
||||
' using HALFAPI_PROD environment variable')
|
||||
PRODUCTION = bool(environ.get('HALFAPI_PROD', False))
|
||||
|
||||
try:
|
||||
from ..conf import SECRET
|
||||
except ImportError:
|
||||
logger.warning('Could not import SECRET variable from conf module,'\
|
||||
' using HALFAPI_SECRET environment variable')
|
||||
SECRET = environ.get('HALFAPI_SECRET', False)
|
||||
if not SECRET:
|
||||
raise Exception('Missing HALFAPI_SECRET variable')
|
||||
|
||||
def cookies_from_scope(scope):
|
||||
cookie = dict(scope.get("headers") or {}).get(b"cookie")
|
||||
if not cookie:
|
||||
return {}
|
||||
|
||||
simple_cookie = SimpleCookie()
|
||||
simple_cookie.load(cookie.decode("utf8"))
|
||||
return {key: morsel.value for key, morsel in simple_cookie.items()}
|
||||
|
||||
def on_auth_error(request: Request, exc: Exception):
|
||||
response = ORJSONResponse({"error": str(exc)}, status_code=401)
|
||||
response.delete_cookie('Authorization')
|
||||
return response
|
||||
class JWTUser(BaseUser):
|
||||
def __init__(self, id: UUID, token: str, payload: dict) -> None:
|
||||
self.__id = id
|
||||
self.token = token
|
||||
self.payload = payload
|
||||
|
||||
def __str__(self):
|
||||
return str(self.json)
|
||||
|
||||
@property
|
||||
def json(self):
|
||||
return {
|
||||
'id' : str(self.__id),
|
||||
'token': self.token,
|
||||
'payload': self.payload
|
||||
}
|
||||
|
||||
@property
|
||||
def is_authenticated(self) -> bool:
|
||||
return True
|
||||
|
||||
@property
|
||||
def id(self) -> str:
|
||||
return self.__id
|
||||
|
||||
|
||||
class JWTAuthenticationBackend(AuthenticationBackend):
|
||||
def __init__(self, secret_key: str = SECRET,
|
||||
|
|
@ -60,103 +95,55 @@ class JWTAuthenticationBackend(AuthenticationBackend):
|
|||
self.algorithm = algorithm
|
||||
self.prefix = prefix
|
||||
|
||||
@property
|
||||
def id(self) -> str:
|
||||
return self.__id
|
||||
|
||||
async def authenticate(
|
||||
self, conn: HTTPConnection
|
||||
) -> typing.Optional[typing.Tuple['AuthCredentials', 'BaseUser']]:
|
||||
|
||||
# Standard way to authenticate via API
|
||||
# https://datatracker.ietf.org/doc/html/rfc7235#section-4.2
|
||||
token = conn.headers.get('Authorization')
|
||||
|
||||
if not token:
|
||||
token = cookies_from_scope(conn.scope).get('Authorization')
|
||||
|
||||
is_check_call = 'check' in conn.query_params
|
||||
|
||||
PRODUCTION = conn.scope['app'].debug == False
|
||||
|
||||
if not token and not is_check_call:
|
||||
return AuthCredentials(), Nobody()
|
||||
async def authenticate(self, request):
|
||||
if "Authorization" not in request.headers:
|
||||
return None
|
||||
|
||||
token = request.headers["Authorization"]
|
||||
try:
|
||||
if token:
|
||||
payload = jwt.decode(token,
|
||||
key=self.secret_key,
|
||||
algorithms=[self.algorithm],
|
||||
options={
|
||||
'verify_signature': True
|
||||
})
|
||||
|
||||
if is_check_call:
|
||||
if token:
|
||||
return AuthCredentials(), CheckUser(payload['user_id'])
|
||||
|
||||
return AuthCredentials(), Nobody()
|
||||
|
||||
algorithms=self.algorithm,
|
||||
verify=True)
|
||||
|
||||
if PRODUCTION and 'debug' in payload.keys() and payload['debug']:
|
||||
raise AuthenticationError(
|
||||
'Trying to connect using *DEBUG* token in *PRODUCTION* mode')
|
||||
|
||||
except jwt.ExpiredSignatureError as exc:
|
||||
return AuthCredentials(), Nobody()
|
||||
except jwt.InvalidTokenError as exc:
|
||||
raise AuthenticationError(str(exc)) from exc
|
||||
except Exception as exc:
|
||||
logger.error('Authentication error : %s', exc)
|
||||
raise exc
|
||||
except jwt.InvalidTokenError as e:
|
||||
raise AuthenticationError(str(e))
|
||||
except Exception as e:
|
||||
print(e)
|
||||
raise e
|
||||
|
||||
|
||||
return AuthCredentials(["authenticated"]), JWTUser(
|
||||
user_id=payload['user_id'], token=token, payload=payload)
|
||||
|
||||
id=payload['id'], token=token, payload=payload)
|
||||
|
||||
|
||||
class JWTWebSocketAuthenticationBackend(AuthenticationBackend):
|
||||
|
||||
def __init__(self, secret_key: str, algorithm: str = 'HS256', query_param_name: str = 'jwt',
|
||||
user_id: UUID = None, audience = None):
|
||||
id: UUID = None, audience = None, options = {}):
|
||||
self.secret_key = secret_key
|
||||
self.algorithm = algorithm
|
||||
self.query_param_name = query_param_name
|
||||
self.__id = user_id
|
||||
self.id = id
|
||||
self.audience = audience
|
||||
self.options = options
|
||||
|
||||
|
||||
async def authenticate(
|
||||
self, conn: HTTPConnection
|
||||
) -> typing.Optional[typing.Tuple["AuthCredentials", "BaseUser"]]:
|
||||
async def authenticate(self, request):
|
||||
if self.query_param_name not in request.query_params:
|
||||
return AuthCredentials(), UnauthenticatedUser()
|
||||
|
||||
if self.query_param_name not in conn.query_params:
|
||||
return AuthCredentials(), Nobody()
|
||||
|
||||
token = conn.query_params[self.query_param_name]
|
||||
token = request.query_params[self.query_param_name]
|
||||
|
||||
try:
|
||||
payload = jwt.decode(
|
||||
token,
|
||||
key=self.secret_key,
|
||||
algorithms=[self.algorithm],
|
||||
audience=self.audience,
|
||||
options={
|
||||
'verify_signature': bool(PRODUCTION)
|
||||
})
|
||||
payload = jwt.decode(token, key=self.secret_key, algorithms=self.algorithm,
|
||||
audience=self.audience, options=self.options)
|
||||
except jwt.InvalidTokenError as e:
|
||||
raise AuthenticationError(str(e))
|
||||
|
||||
if PRODUCTION and 'debug' in payload.keys() and payload['debug']:
|
||||
raise AuthenticationError(
|
||||
'Trying to connect using *DEBUG* token in *PRODUCTION* mode')
|
||||
|
||||
except jwt.InvalidTokenError as exc:
|
||||
raise AuthenticationError(str(exc)) from exc
|
||||
|
||||
return (
|
||||
AuthCredentials(["authenticated"]),
|
||||
JWTUser(
|
||||
user_id=payload['id'],
|
||||
token=token,
|
||||
payload=payload)
|
||||
)
|
||||
return AuthCredentials(["authenticated"]), JWTUser(id = payload['id'],
|
||||
token=token, payload=payload)
|
||||
|
|
|
|||
|
|
@ -1,16 +1,12 @@
|
|||
#!/usr/bin/env python3
|
||||
from starlette.exceptions import HTTPException
|
||||
|
||||
"""
|
||||
This is the *query* library that contains all the useful functions to treat our
|
||||
queries
|
||||
|
||||
Fonction:
|
||||
- parse_query
|
||||
"""
|
||||
|
||||
from starlette.exceptions import HTTPException
|
||||
|
||||
|
||||
def parse_query(q_string: str = ""):
|
||||
def parse_query(q: str = ""):
|
||||
"""
|
||||
Returns the fitting Response object according to query parameters.
|
||||
|
||||
|
|
@ -19,7 +15,7 @@ def parse_query(q_string: str = ""):
|
|||
It returns a callable function that returns the desired Response object.
|
||||
|
||||
Parameters:
|
||||
q_string (str): The query string "q" parameter, in the format
|
||||
q (str): The query string "q" parameter, in the format
|
||||
key0:value0|...|keyN:valueN
|
||||
|
||||
Returns:
|
||||
|
|
@ -56,23 +52,25 @@ def parse_query(q_string: str = ""):
|
|||
>>> parse_query('limit:10')
|
||||
<function parse_query.<locals>.select at 0x...>
|
||||
|
||||
# >>> parse_query('limit=10')
|
||||
# starlette.exceptions.HTTPException: 400
|
||||
>>> parse_query('limit=10')
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
starlette.exceptions.HTTPException: 400
|
||||
|
||||
|
||||
"""
|
||||
|
||||
params = {}
|
||||
if len(q_string) > 0:
|
||||
if len(q) > 0:
|
||||
try:
|
||||
split_ = lambda x : x.split(':')
|
||||
params = dict(map(split_, q_string.split('|')))
|
||||
except ValueError as exc:
|
||||
raise HTTPException(400) from exc
|
||||
params = dict(map(split_, q.split('|')))
|
||||
except ValueError:
|
||||
raise HTTPException(400)
|
||||
split_ = lambda x : x.split(':')
|
||||
params = dict(map(split_, q_string.split('|')))
|
||||
params = dict(map(split_, q.split('|')))
|
||||
|
||||
def select(obj, fields):
|
||||
def select(obj, fields = []):
|
||||
|
||||
if 'limit' in params and int(params['limit']) > 0:
|
||||
obj.limit(int(params['limit']))
|
||||
|
|
@ -80,6 +78,6 @@ def parse_query(q_string: str = ""):
|
|||
if 'offset' in params and int(params['offset']) > 0:
|
||||
obj.offset(int(params['offset']))
|
||||
|
||||
return list(obj.select(*fields))
|
||||
return [elt for elt in obj.select(*fields)]
|
||||
|
||||
return select
|
||||
|
|
|
|||
|
|
@ -1,44 +1,19 @@
|
|||
#!/usr/bin/env python3
|
||||
# builtins
|
||||
""" Response module
|
||||
|
||||
Contains some base response classes
|
||||
|
||||
Classes :
|
||||
- HJSONResponse
|
||||
- InternalServerErrorResponse
|
||||
- NotFoundResponse
|
||||
- NotImplementedResponse
|
||||
- ORJSONResponse
|
||||
- PlainTextResponse
|
||||
- ServiceUnavailableResponse
|
||||
- UnauthorizedResponse
|
||||
- ODSResponse
|
||||
|
||||
"""
|
||||
import numbers
|
||||
import csv
|
||||
from datetime import date
|
||||
import decimal
|
||||
import typing
|
||||
from io import BytesIO
|
||||
import orjson
|
||||
from io import TextIOBase, StringIO
|
||||
from half_orm.null import NULL
|
||||
|
||||
# asgi framework
|
||||
from starlette.responses import PlainTextResponse, Response, JSONResponse, HTMLResponse
|
||||
from starlette.requests import Request
|
||||
from starlette.exceptions import HTTPException
|
||||
|
||||
from .user import JWTUser, Nobody
|
||||
from ..logging import logger
|
||||
|
||||
from starlette.responses import PlainTextResponse, Response, JSONResponse
|
||||
|
||||
__all__ = [
|
||||
'HJSONResponse',
|
||||
'InternalServerErrorResponse',
|
||||
'NotFoundResponse',
|
||||
'NotImplementedResponse',
|
||||
'ORJSONResponse',
|
||||
'PlainTextResponse',
|
||||
'ServiceUnavailableResponse',
|
||||
'UnauthorizedResponse']
|
||||
|
||||
|
||||
|
|
@ -62,11 +37,6 @@ class NotImplementedResponse(Response):
|
|||
def __init__(self, *args, **kwargs):
|
||||
super().__init__(status_code=501)
|
||||
|
||||
class ServiceUnavailableResponse(Response):
|
||||
""" The 503 Service Unavailable default Response
|
||||
"""
|
||||
def __init__(self, *args, **kwargs):
|
||||
super().__init__(status_code=503)
|
||||
|
||||
class UnauthorizedResponse(Response):
|
||||
""" The 401 Not Found default Response
|
||||
|
|
@ -74,94 +44,26 @@ class UnauthorizedResponse(Response):
|
|||
def __init__(self, *args, **kwargs):
|
||||
super().__init__(status_code = 401)
|
||||
|
||||
|
||||
class ORJSONResponse(JSONResponse):
|
||||
""" The response that encodes data into JSON
|
||||
"""
|
||||
def __init__(self, content, default=None, **kwargs):
|
||||
self.default = default if default is not None else ORJSONResponse.default_cast
|
||||
super().__init__(content, **kwargs)
|
||||
|
||||
def render(self, content: typing.Any) -> bytes:
|
||||
return orjson.dumps(content,
|
||||
option=orjson.OPT_NON_STR_KEYS,
|
||||
default=self.default)
|
||||
|
||||
@staticmethod
|
||||
def default_cast(typ):
|
||||
""" Cast the data in JSON-serializable type
|
||||
"""
|
||||
str_types = {
|
||||
decimal.Decimal
|
||||
}
|
||||
list_types = {
|
||||
set
|
||||
}
|
||||
jsonable_types = {
|
||||
JWTUser, Nobody
|
||||
}
|
||||
|
||||
if callable(typ):
|
||||
return typ.__name__
|
||||
if type(typ) in str_types:
|
||||
return str(typ)
|
||||
if type(typ) in list_types:
|
||||
return list(typ)
|
||||
if type(typ) in jsonable_types:
|
||||
return typ.json
|
||||
|
||||
raise TypeError(f'Type {type(typ)} is not handled by ORJSONResponse')
|
||||
|
||||
|
||||
class HJSONResponse(ORJSONResponse):
|
||||
""" The response that encodes generator data into JSON
|
||||
"""
|
||||
def render(self, content: typing.Generator):
|
||||
return super().render(list(content))
|
||||
|
||||
class ODSResponse(Response):
|
||||
file_type = 'ods'
|
||||
|
||||
def __init__(self, d_rows: typing.List[typing.Dict]):
|
||||
try:
|
||||
import pyexcel as pe
|
||||
except ImportError:
|
||||
""" ODSResponse is not handled
|
||||
"""
|
||||
super().__init__(content=
|
||||
'pyexcel is not installed, ods format not available'
|
||||
)
|
||||
return
|
||||
|
||||
with BytesIO() as ods_file:
|
||||
rows = []
|
||||
if len(d_rows):
|
||||
rows_names = list(d_rows[0].keys())
|
||||
for elt in d_rows:
|
||||
rows.append(list(elt.values()))
|
||||
|
||||
rows.insert(0, rows_names)
|
||||
|
||||
self.sheet = pe.Sheet(rows)
|
||||
self.sheet.save_to_memory(
|
||||
file_type=self.file_type,
|
||||
stream=ods_file)
|
||||
|
||||
filename = f'{date.today()}.{self.file_type}'
|
||||
|
||||
class HJSONResponse(JSONResponse):
|
||||
def __init__(self, obj):
|
||||
obj = self.__serialize(obj)
|
||||
super().__init__(
|
||||
content=ods_file.getvalue(),
|
||||
headers={
|
||||
'Content-Type': 'application/vnd.oasis.opendocument.spreadsheet; charset=UTF-8',
|
||||
'Content-Disposition': f'attachment; filename="{filename}"'},
|
||||
content=obj,
|
||||
status_code = 200)
|
||||
|
||||
|
||||
class XLSXResponse(ODSResponse):
|
||||
file_type = 'xlsx'
|
||||
|
||||
def gen_exception_route(response_cls):
|
||||
async def exception_route(req: Request, exc: HTTPException):
|
||||
return response_cls()
|
||||
|
||||
return exception_route
|
||||
def __serialize(self, obj):
|
||||
if isinstance(obj, dict):
|
||||
robj = dict()
|
||||
for key, value in obj.items():
|
||||
robj[key] = self.__serialize(value)
|
||||
return robj
|
||||
if isinstance(obj, list):
|
||||
robj = []
|
||||
for value in obj:
|
||||
robj.append(self.__serialize(value))
|
||||
return robj
|
||||
if isinstance(obj, numbers.Number) or isinstance(obj, str):
|
||||
return obj
|
||||
if obj == NULL:
|
||||
return None
|
||||
return str(obj)
|
||||
|
|
|
|||
|
|
@ -1,12 +0,0 @@
|
|||
import os
|
||||
import sys
|
||||
import subprocess
|
||||
from types import ModuleType
|
||||
from typing import Dict
|
||||
from pprint import pprint
|
||||
|
||||
from schema import SchemaError
|
||||
from .constants import VERBS, ROUTER_SCHEMA
|
||||
from ..logging import logger
|
||||
|
||||
|
||||
|
|
@ -1,136 +1,84 @@
|
|||
#!/usr/bin/env python3
|
||||
"""
|
||||
Routes module
|
||||
from functools import wraps
|
||||
import importlib
|
||||
import sys
|
||||
|
||||
Classes :
|
||||
- JSONRoute
|
||||
from halfapi.conf import (PROJECT_NAME, DB_NAME, HOST, PORT,
|
||||
PRODUCTION, DOMAINS)
|
||||
|
||||
Fonctions :
|
||||
- gen_domain_routes
|
||||
- gen_schema_routes
|
||||
- api_routes
|
||||
|
||||
Exception :
|
||||
- DomainNotFoundError
|
||||
|
||||
"""
|
||||
import inspect
|
||||
|
||||
from typing import Coroutine, Dict, Generator, Tuple, Any
|
||||
from types import ModuleType, FunctionType
|
||||
|
||||
import yaml
|
||||
|
||||
# from .domain import gen_router_routes, domain_acls, route_decorator, domain_schema
|
||||
from .responses import ORJSONResponse
|
||||
from .acl import args_check
|
||||
from ..half_route import HalfRoute
|
||||
from . import acl
|
||||
|
||||
from ..logging import logger
|
||||
from halfapi.db import (
|
||||
Domain,
|
||||
APIRouter,
|
||||
APIRoute,
|
||||
AclFunction,
|
||||
Acl)
|
||||
from halfapi.lib.responses import *
|
||||
from starlette.exceptions import HTTPException
|
||||
from starlette.routing import Mount, Route
|
||||
from starlette.requests import Request
|
||||
|
||||
class DomainNotFoundError(Exception):
|
||||
""" Exception when a domain is not importable
|
||||
"""
|
||||
pass
|
||||
|
||||
def JSONRoute(data: Any) -> Coroutine:
|
||||
"""
|
||||
Returns a route function that returns the data as JSON
|
||||
def get_routes(domains=None):
|
||||
""" Procedure to mount the registered domains on their prefixes
|
||||
|
||||
Parameters:
|
||||
data (Any):
|
||||
The data to return
|
||||
|
||||
Returns:
|
||||
async function
|
||||
- app (ASGIApp): The Starlette instance
|
||||
- domains (list): The domains to mount, retrieved from the database
|
||||
with their attributes "name"
|
||||
|
||||
Returns: Nothing
|
||||
"""
|
||||
async def wrapped(request, *args, **kwargs):
|
||||
return ORJSONResponse(data)
|
||||
|
||||
return wrapped
|
||||
|
||||
|
||||
def gen_domain_routes(m_domain: ModuleType):
|
||||
"""
|
||||
Yields the Route objects for a domain
|
||||
def route_decorator(fct, acls_mod, acls):
|
||||
@wraps(fct)
|
||||
async def caller(req: Request, *args, **kwargs):
|
||||
for acl_fct_name in acls:
|
||||
acl_fct = getattr(acls_mod, acl_fct_name)
|
||||
if acl_fct(req, *args, **kwargs):
|
||||
return await fct(req, *args, **kwargs)
|
||||
|
||||
Parameters:
|
||||
m_domains: ModuleType
|
||||
raise HTTPException(401)
|
||||
|
||||
Returns:
|
||||
Generator(HalfRoute)
|
||||
"""
|
||||
yield HalfRoute('/',
|
||||
JSONRoute(domain_schema(m_domain)),
|
||||
[{'acl': acl.public}],
|
||||
'GET'
|
||||
return caller
|
||||
|
||||
app_routes = []
|
||||
for domain_name in DOMAINS:
|
||||
try:
|
||||
domain = next(Domain(name=domain_name).select())
|
||||
except StopIteration:
|
||||
raise DomainNotFoundError(
|
||||
f"Domain '{domain_name}' not found in '{DB_NAME}' database!")
|
||||
domain_acl_mod = importlib.import_module(f'{domain["name"]}.acl')
|
||||
domain_routes = []
|
||||
for router in APIRouter(domain=domain['name']).select():
|
||||
router_routes = []
|
||||
|
||||
router_mod = importlib.import_module(
|
||||
'{domain}.routers.{name}'.format(**router))
|
||||
|
||||
with APIRoute(domain=domain['name'],
|
||||
router=router['name']) as routes:
|
||||
for route in routes.select():
|
||||
fct_name = route.pop('fct_name')
|
||||
acls = [ list(elt.values()).pop()
|
||||
for elt in Acl(**route).select('acl_fct_name') ]
|
||||
|
||||
router_routes.append(
|
||||
Route(route['path'],
|
||||
route_decorator(
|
||||
getattr(router_mod, fct_name),
|
||||
domain_acl_mod,
|
||||
acls
|
||||
), methods=[route['http_verb']])
|
||||
)
|
||||
|
||||
for path, method, m_router, fct, params in gen_router_routes(m_domain, []):
|
||||
yield HalfRoute(f'/{path}', fct, params, method)
|
||||
domain_routes.append(
|
||||
Mount('/{name}'.format(**router), routes=router_routes))
|
||||
|
||||
|
||||
def gen_schema_routes(schema: Dict):
|
||||
"""
|
||||
Yields the Route objects according to a given schema
|
||||
"""
|
||||
for path, methods in schema.items():
|
||||
for verb, definition in methods.items():
|
||||
fct = definition.pop('fct')
|
||||
acls = definition.pop('acls')
|
||||
# TODO: Check what to do with gen_routes, it is almost the same function
|
||||
if not inspect.iscoroutinefunction(fct):
|
||||
yield HalfRoute(path, route_decorator(fct), acls, verb)
|
||||
else:
|
||||
yield HalfRoute(path, args_check(fct), acls, verb)
|
||||
|
||||
|
||||
def api_routes(m_dom: ModuleType) -> Tuple[Dict, Dict]:
|
||||
"""
|
||||
Yields the description objects for HalfAPI app routes
|
||||
|
||||
Parameters:
|
||||
m_dom (ModuleType): the halfapi module
|
||||
|
||||
Returns:
|
||||
(Dict, Dict)
|
||||
"""
|
||||
|
||||
d_acls = {}
|
||||
|
||||
def str_acl(params):
|
||||
l_params = []
|
||||
|
||||
for param in params:
|
||||
|
||||
if 'acl' not in param.keys() or not param['acl']:
|
||||
continue
|
||||
|
||||
l_params.append(param.copy())
|
||||
l_params[-1]['acl'] = param['acl'].__name__
|
||||
|
||||
if param['acl'] not in d_acls.keys():
|
||||
d_acls[param['acl'].__name__] = param['acl']
|
||||
|
||||
return l_params
|
||||
|
||||
d_res = {}
|
||||
for path, verb, m_router, fct, params in gen_router_routes(m_dom, []):
|
||||
try:
|
||||
if path not in d_res:
|
||||
d_res[path] = {}
|
||||
|
||||
d_res[path][verb] = {
|
||||
'docs': yaml.load(fct.__doc__, Loader=yaml.FullLoader),
|
||||
'acls': str_acl(params)
|
||||
}
|
||||
except Exception as exc:
|
||||
logger.error("""Error in route generation
|
||||
path:%s
|
||||
verb:%s
|
||||
router:%s
|
||||
fct:%s
|
||||
params:%s """, path, verb, m_router, fct, params)
|
||||
raise exc
|
||||
|
||||
return d_res, d_acls
|
||||
app_routes.append(Mount('/{name}'.format(**domain),
|
||||
routes=domain_routes))
|
||||
return app_routes
|
||||
|
|
|
|||
|
|
@ -1,137 +0,0 @@
|
|||
""" Schemas module
|
||||
|
||||
Functions :
|
||||
- schema_json
|
||||
- schema_dict_dom
|
||||
- get_acls
|
||||
|
||||
Constant :
|
||||
SCHEMAS (starlette.schemas.SchemaGenerator)
|
||||
"""
|
||||
|
||||
import os
|
||||
import importlib
|
||||
from typing import Dict, Coroutine, List
|
||||
from types import ModuleType
|
||||
import yaml
|
||||
|
||||
from starlette.schemas import SchemaGenerator
|
||||
|
||||
from .. import __version__
|
||||
from ..logging import logger
|
||||
from .routes import api_routes
|
||||
from .responses import ORJSONResponse
|
||||
|
||||
SCHEMAS = SchemaGenerator(
|
||||
{"openapi": "3.0.0", "info": {"title": "HalfAPI", "version": __version__}}
|
||||
)
|
||||
|
||||
async def schema_json(request, *args, **kwargs):
|
||||
"""
|
||||
description: |
|
||||
Returns the current API routes description (OpenAPI v3)
|
||||
as a JSON object
|
||||
responses:
|
||||
200:
|
||||
description: API Schema in OpenAPI v3 format
|
||||
"""
|
||||
return ORJSONResponse(
|
||||
SCHEMAS.get_schema(routes=request.app.routes))
|
||||
|
||||
|
||||
def schema_csv_dict(csv: List[str], prefix='/') -> Dict:
|
||||
package = None
|
||||
schema_d = {}
|
||||
|
||||
modules_d = {}
|
||||
|
||||
acl_modules_d = {}
|
||||
|
||||
|
||||
for line in csv:
|
||||
if not line:
|
||||
continue
|
||||
|
||||
path, verb, router, acl_fct_name, args_req, args_opt, out = line.strip().split(';')
|
||||
logger.info('schema_csv_dict %s %s %s', path, args_req, args_opt)
|
||||
path = f'{prefix}{path}'
|
||||
|
||||
if path not in schema_d:
|
||||
schema_d[path] = {}
|
||||
|
||||
|
||||
if verb not in schema_d[path]:
|
||||
mod_str = router.split(':')[0]
|
||||
fct_str = router.split(':')[1]
|
||||
|
||||
if mod_str not in modules_d:
|
||||
modules_d[mod_str] = importlib.import_module(mod_str)
|
||||
|
||||
if not hasattr(modules_d[mod_str], fct_str):
|
||||
raise Exception(
|
||||
'Missing function in module. module:{} function:{}'.format(
|
||||
router, fct_str
|
||||
)
|
||||
)
|
||||
|
||||
fct = getattr(modules_d[mod_str], fct_str)
|
||||
|
||||
schema_d[path][verb] = {
|
||||
'module': modules_d[mod_str],
|
||||
'fct': fct,
|
||||
'acls': []
|
||||
}
|
||||
|
||||
if package and router.split('.')[0] != package:
|
||||
raise Exception('Multi-domain is not allowed in that mode')
|
||||
|
||||
package = router.split('.')[0]
|
||||
if not len(package):
|
||||
raise Exception(
|
||||
'Empty package name (router=%s)'.format(router))
|
||||
|
||||
acl_package = f'{package}.acl'
|
||||
|
||||
if acl_package not in acl_modules_d:
|
||||
if acl_package not in modules_d:
|
||||
modules_d[acl_package] = importlib.import_module(acl_package)
|
||||
if not hasattr(modules_d[acl_package], acl_fct_name):
|
||||
raise Exception(
|
||||
'Missing acl function in module. module:{} acl:{}'.format(
|
||||
acl_package, acl_fct_name
|
||||
)
|
||||
)
|
||||
|
||||
acl_modules_d[acl_package] = {}
|
||||
|
||||
acl_modules_d[acl_package][acl_fct_name] = getattr(modules_d[acl_package], acl_fct_name)
|
||||
|
||||
schema_d[path][verb]['acls'].append({
|
||||
'acl': acl_modules_d[acl_package][acl_fct_name],
|
||||
'args': {
|
||||
'required': set(args_req.split(',')) if len(args_req) else set(),
|
||||
'optional': set(args_opt.split(',')) if len(args_opt) else set()
|
||||
}
|
||||
})
|
||||
|
||||
return schema_d
|
||||
|
||||
def param_docstring_default(name, type):
|
||||
""" Returns a default docstring in OpenAPI format for a path parameter
|
||||
"""
|
||||
type_map = {
|
||||
'str': 'string',
|
||||
'uuid': 'string',
|
||||
'path': 'string',
|
||||
'int': 'number',
|
||||
'float': 'number'
|
||||
}
|
||||
return yaml.dump({
|
||||
'name': name,
|
||||
'in': 'path',
|
||||
'description': f'default description for path parameter {name}',
|
||||
'required': True,
|
||||
'schema': {
|
||||
'type': type_map[type]
|
||||
}
|
||||
})
|
||||
|
|
@ -1,23 +0,0 @@
|
|||
"""
|
||||
Timing module
|
||||
|
||||
Helpers to gathers stats on requests timing
|
||||
|
||||
class HTimingClient
|
||||
"""
|
||||
import logging
|
||||
|
||||
from timing_asgi import TimingClient
|
||||
|
||||
from ..logging import logger
|
||||
|
||||
class HTimingClient(TimingClient):
|
||||
""" Used to redefine TimingClient.timing
|
||||
"""
|
||||
def timing(self, metric_name, timing, tags):
|
||||
tags_d = dict(map(lambda elt: elt.split(':'), tags))
|
||||
|
||||
logger.debug('[TIME:%s][%s] %s %s - %sms',
|
||||
tags_d['time'], metric_name,
|
||||
tags_d['http_method'], tags_d['http_status'],
|
||||
round(timing*1000, 2))
|
||||
|
|
@ -1,79 +0,0 @@
|
|||
from uuid import UUID
|
||||
from starlette.authentication import BaseUser, UnauthenticatedUser
|
||||
|
||||
class Nobody(UnauthenticatedUser):
|
||||
""" Nobody class
|
||||
|
||||
The default class when no token is passed
|
||||
"""
|
||||
@property
|
||||
def json(self):
|
||||
return {
|
||||
'id' : '',
|
||||
'token': '',
|
||||
'payload': ''
|
||||
}
|
||||
|
||||
|
||||
class JWTUser(BaseUser):
|
||||
""" JWTUser class
|
||||
|
||||
Is used to store authentication informations
|
||||
"""
|
||||
def __init__(self, user_id: UUID, token: str, payload: dict) -> None:
|
||||
self.__id = user_id
|
||||
self.token = token
|
||||
self.payload = payload
|
||||
|
||||
def __str__(self):
|
||||
return str(self.json)
|
||||
|
||||
@property
|
||||
def json(self):
|
||||
return {
|
||||
'id' : str(self.__id),
|
||||
'token': self.token,
|
||||
'payload': self.payload
|
||||
}
|
||||
|
||||
@property
|
||||
def is_authenticated(self) -> bool:
|
||||
return True
|
||||
|
||||
@property
|
||||
def display_name(self) -> str:
|
||||
return ' '.join(
|
||||
(self.payload.get('name'), self.payload.get('firstname')))
|
||||
|
||||
@property
|
||||
def id(self) -> str:
|
||||
return self.__id
|
||||
|
||||
|
||||
class CheckUser(BaseUser):
|
||||
""" CheckUser class
|
||||
|
||||
Is used to call checks with give user_id, to know if it passes the ACLs for
|
||||
the given route.
|
||||
|
||||
It should never be able to run a route function.
|
||||
"""
|
||||
def __init__(self, user_id: UUID) -> None:
|
||||
self.__id = user_id
|
||||
|
||||
|
||||
@property
|
||||
def is_authenticated(self) -> bool:
|
||||
return True
|
||||
|
||||
@property
|
||||
def display_name(self) -> str:
|
||||
return 'check_user'
|
||||
|
||||
@property
|
||||
def id(self) -> str:
|
||||
return self.__id
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
@ -1,32 +0,0 @@
|
|||
import logging
|
||||
|
||||
default_level = logging.DEBUG
|
||||
default_format = '%(asctime)s [%(process)d] [%(levelname)s] %(message)s'
|
||||
default_datefmt = '[%Y-%m-%d %H:%M:%S %z]'
|
||||
|
||||
def config_logging(level=default_level, format=default_format, datefmt=default_datefmt):
|
||||
# When run by 'uvicorn ...', a root handler is already
|
||||
# configured and the basicConfig below does nothing.
|
||||
# To get the desired formatting:
|
||||
logging.getLogger().handlers.clear()
|
||||
|
||||
# 'uvicorn --log-config' is broken so we configure in the app.
|
||||
# https://github.com/encode/uvicorn/issues/511
|
||||
logging.basicConfig(
|
||||
# match gunicorn format
|
||||
format=format,
|
||||
datefmt=datefmt,
|
||||
level=level)
|
||||
|
||||
# When run by 'gunicorn -k uvicorn.workers.UvicornWorker ...',
|
||||
# These loggers are already configured and propogating.
|
||||
# So we have double logging with a root logger.
|
||||
# (And setting propagate = False hurts the other usage.)
|
||||
logging.getLogger('uvicorn.asgi').handlers.clear()
|
||||
logging.getLogger('uvicorn.access').handlers.clear()
|
||||
logging.getLogger('uvicorn.error').handlers.clear()
|
||||
logging.getLogger('uvicorn.asgi').propagate = True
|
||||
logging.getLogger('uvicorn.access').propagate = True
|
||||
logging.getLogger('uvicorn.error').propagate = True
|
||||
|
||||
logger = logging.getLogger()
|
||||
|
|
@ -0,0 +1,74 @@
|
|||
create schema api;
|
||||
|
||||
create type verb as enum ('POST', 'GET', 'PUT', 'DELETE');
|
||||
|
||||
create table api.domain (
|
||||
name text,
|
||||
primary key (name)
|
||||
);
|
||||
|
||||
create table api.router (
|
||||
name text,
|
||||
domain text,
|
||||
primary key (name, domain)
|
||||
);
|
||||
|
||||
alter table api.router add constraint router_domain_fkey foreign key (domain) references api.domain(name) on update cascade on delete cascade;
|
||||
|
||||
create table api.route (
|
||||
http_verb verb,
|
||||
path text, -- relative to /<domain>/<router>
|
||||
fct_name text,
|
||||
router text,
|
||||
domain text,
|
||||
primary key (http_verb, path, router, domain)
|
||||
);
|
||||
|
||||
alter table api.route add constraint route_router_fkey foreign key (router, domain) references api.router(name, domain) on update cascade on delete cascade;
|
||||
|
||||
create table api.acl_function (
|
||||
name text,
|
||||
description text,
|
||||
domain text,
|
||||
primary key (name, domain)
|
||||
);
|
||||
|
||||
alter table api.acl_function add constraint acl_function_domain_fkey foreign key (domain) references api.domain(name) on update cascade on delete cascade;
|
||||
|
||||
create table api.acl (
|
||||
http_verb verb,
|
||||
path text not null,
|
||||
router text,
|
||||
domain text,
|
||||
acl_fct_name text,
|
||||
primary key (http_verb, path, router, domain, acl_fct_name)
|
||||
);
|
||||
|
||||
alter table api.acl add constraint acl_route_fkey foreign key (http_verb, path,
|
||||
router, domain) references api.route(http_verb, path, router, domain) on update cascade on delete cascade;
|
||||
alter table api.acl add constraint acl_function_fkey foreign key (acl_fct_name, domain) references api.acl_function(name, domain) on update cascade on delete cascade;
|
||||
|
||||
create schema "api.view";
|
||||
|
||||
create view "api.view".route as
|
||||
select
|
||||
route.*,
|
||||
'/'::text || route.domain || '/'::text || route.router || route.path AS abs_path
|
||||
from
|
||||
api.route
|
||||
join api.domain on
|
||||
route.domain = domain.name
|
||||
;
|
||||
|
||||
create view "api.view".acl as
|
||||
select
|
||||
acl.*,
|
||||
'/'::text || route.domain || '/'::text || route.router || route.path AS abs_path
|
||||
from
|
||||
api.acl
|
||||
join api.acl_function on
|
||||
acl.acl_fct_name = acl_function.name
|
||||
join api.route on
|
||||
acl.domain = route.domain
|
||||
and acl.router = route.router
|
||||
and acl.path = route.path;
|
||||
|
|
@ -1,152 +0,0 @@
|
|||
import importlib
|
||||
import functools
|
||||
import os
|
||||
import sys
|
||||
import json
|
||||
from json.decoder import JSONDecodeError
|
||||
import toml
|
||||
from unittest import TestCase
|
||||
from starlette.testclient import TestClient
|
||||
from click.testing import CliRunner
|
||||
from ..cli.cli import cli
|
||||
from ..halfapi import HalfAPI
|
||||
from ..half_domain import HalfDomain
|
||||
from ..conf import DEFAULT_CONF
|
||||
from pprint import pprint
|
||||
import tempfile
|
||||
|
||||
class TestDomain(TestCase):
|
||||
@property
|
||||
def domain_name(self):
|
||||
return getattr(self, 'DOMAIN')
|
||||
|
||||
@property
|
||||
def module_name(self):
|
||||
return getattr(self, 'MODULE', self.domain_name)
|
||||
|
||||
@property
|
||||
def acl_path(self):
|
||||
return getattr(self, 'ACL', '.acl')
|
||||
|
||||
@property
|
||||
def router_path(self):
|
||||
return getattr(self, 'ROUTERS', '.routers')
|
||||
|
||||
@property
|
||||
def router_module(self):
|
||||
return '.'.join((self.module_name, self.ROUTERS))
|
||||
|
||||
|
||||
def setUp(self):
|
||||
# CLI
|
||||
class_ = CliRunner
|
||||
def invoke_wrapper(f):
|
||||
"""Augment CliRunner.invoke to emit its output to stdout.
|
||||
|
||||
This enables pytest to show the output in its logs on test
|
||||
failures.
|
||||
|
||||
"""
|
||||
@functools.wraps(f)
|
||||
def wrapper(*args, **kwargs):
|
||||
echo = kwargs.pop('echo', False)
|
||||
result = f(*args, **kwargs)
|
||||
|
||||
if echo is True:
|
||||
sys.stdout.write(result.output)
|
||||
|
||||
return result
|
||||
|
||||
return wrapper
|
||||
|
||||
class_.invoke = invoke_wrapper(class_.invoke)
|
||||
self.runner = class_(mix_stderr=False)
|
||||
|
||||
# HTTP
|
||||
# Fake default values of default configuration
|
||||
self.halfapi_conf = {
|
||||
'secret': 'testsecret',
|
||||
'production': False,
|
||||
'domain': {}
|
||||
}
|
||||
|
||||
self.halfapi_conf['domain'][self.domain_name] = {
|
||||
'name': self.domain_name,
|
||||
'router': self.router_path,
|
||||
'acl': self.acl_path,
|
||||
'module': self.module_name,
|
||||
'prefix': False,
|
||||
'enabled': True,
|
||||
'config': getattr(self, 'CONFIG', {})
|
||||
}
|
||||
|
||||
_, self.config_file = tempfile.mkstemp()
|
||||
with open(self.config_file, 'w') as fh:
|
||||
fh.write(toml.dumps(self.halfapi_conf))
|
||||
|
||||
self.halfapi = HalfAPI(self.halfapi_conf)
|
||||
|
||||
self.client = TestClient(self.halfapi.application)
|
||||
|
||||
self.module = importlib.import_module(
|
||||
self.module_name
|
||||
)
|
||||
|
||||
|
||||
def tearDown(self):
|
||||
pass
|
||||
|
||||
def check_domain(self):
|
||||
result = None
|
||||
try:
|
||||
result = self.runner.invoke(cli, '--version')
|
||||
self.assertEqual(result.exit_code, 0)
|
||||
result = self.runner.invoke(cli, ['domain', '--read', self.DOMAIN, self.config_file])
|
||||
self.assertEqual(result.exit_code, 0)
|
||||
result_d = json.loads(result.stdout)
|
||||
result = self.runner.invoke(cli, ['run', '--help'])
|
||||
self.assertEqual(result.exit_code, 0)
|
||||
# result = self.runner.invoke(cli, ['run', '--dryrun', self.DOMAIN])
|
||||
# self.assertEqual(result.exit_code, 0)
|
||||
except AssertionError as exc:
|
||||
print(f'Result {result}')
|
||||
print(f'Stdout {result.stdout}')
|
||||
print(f'Stderr {result.stderr}')
|
||||
raise exc
|
||||
except JSONDecodeError as exc:
|
||||
print(f'Result {result}')
|
||||
print(f'Stdout {result.stdout}')
|
||||
raise exc
|
||||
|
||||
|
||||
|
||||
return result_d
|
||||
|
||||
def check_routes(self):
|
||||
r = self.client.request('get', '/')
|
||||
assert r.status_code == 200
|
||||
schema = r.json()
|
||||
assert isinstance(schema, dict)
|
||||
assert 'openapi' in schema
|
||||
assert 'info' in schema
|
||||
assert 'paths' in schema
|
||||
|
||||
r = self.client.request('get', '/halfapi/acls')
|
||||
assert r.status_code == 200
|
||||
d_r = r.json()
|
||||
assert isinstance(d_r, dict)
|
||||
assert self.domain_name in d_r.keys()
|
||||
|
||||
ACLS = HalfDomain.acls(self.module, self.acl_path)
|
||||
assert len(ACLS) == len(d_r[self.domain_name])
|
||||
|
||||
for acl_rule in ACLS:
|
||||
assert len(acl_rule.name) > 0
|
||||
assert acl_rule.name in d_r[self.domain_name]
|
||||
assert len(acl_rule.documentation) > 0
|
||||
assert isinstance(acl_rule.priority, int)
|
||||
assert acl_rule.priority >= 0
|
||||
|
||||
if acl_rule.public is True:
|
||||
r = self.client.request('get', f'/halfapi/acls/{acl_rule.name}')
|
||||
assert r.status_code in [200, 401]
|
||||
|
|
@ -1,3 +0,0 @@
|
|||
pyexcel>=0.6.3,<1
|
||||
pyexcel-ods>=0.5.6,<1
|
||||
pyexcel-xlsx=0.6.0,<1
|
||||
|
|
@ -1,5 +1,4 @@
|
|||
[pytest]
|
||||
testpaths = tests halfapi
|
||||
addopts = --doctest-modules
|
||||
doctest_optionflags = ELLIPSIS IGNORE_EXCEPTION_DETAIL
|
||||
pythonpath = ./tests
|
||||
addopts = --doctest-modules -rP --log-level debug
|
||||
doctest_optionflags = ELLIPSIS
|
||||
|
|
|
|||
|
|
@ -1,61 +1,6 @@
|
|||
alog==0.9.13
|
||||
anyio==3.4.0
|
||||
asgiref==3.4.1
|
||||
astroid==2.9.0
|
||||
attrs==21.2.0
|
||||
bleach==4.1.0
|
||||
build==0.7.0
|
||||
certifi==2021.10.8
|
||||
cffi==1.15.0
|
||||
charset-normalizer==2.0.9
|
||||
click==7.1.2
|
||||
colorama==0.4.4
|
||||
contextlib2==21.6.0
|
||||
cryptography==36.0.1
|
||||
docutils==0.18.1
|
||||
h11==0.12.0
|
||||
idna==3.3
|
||||
importlib-metadata==4.8.2
|
||||
iniconfig==1.1.1
|
||||
isort==5.10.1
|
||||
jeepney==0.7.1
|
||||
keyring==23.4.0
|
||||
lazy-object-proxy==1.7.1
|
||||
mccabe==0.6.1
|
||||
orjson==3.6.5
|
||||
packaging==21.3
|
||||
pep517==0.12.0
|
||||
pkginfo==1.8.2
|
||||
platformdirs==2.4.0
|
||||
pluggy==1.0.0
|
||||
py==1.11.0
|
||||
pycparser==2.21
|
||||
pyflakes==2.4.0
|
||||
Pygments==2.10.0
|
||||
PyJWT==2.3.0
|
||||
pylint==2.12.2
|
||||
pyparsing==3.0.6
|
||||
pytest==6.2.5
|
||||
pytest-asyncio==0.16.0
|
||||
pytest-pythonpath==0.7.3
|
||||
PyYAML==5.4.1
|
||||
readme-renderer==32.0
|
||||
requests==2.26.0
|
||||
requests-toolbelt==0.9.1
|
||||
rfc3986==1.5.0
|
||||
schema==0.7.5
|
||||
SecretStorage==3.3.1
|
||||
six==1.16.0
|
||||
sniffio==1.2.0
|
||||
starlette==0.17.1
|
||||
timing-asgi==0.2.1
|
||||
toml==0.10.2
|
||||
tomli==2.0.0
|
||||
tqdm==4.62.3
|
||||
twine==3.7.1
|
||||
urllib3==1.26.7
|
||||
uvicorn==0.16.0
|
||||
vulture==2.3
|
||||
webencodings==0.5.1
|
||||
wrapt==1.13.3
|
||||
zipp==3.6.0
|
||||
click
|
||||
starlette
|
||||
uvicorn
|
||||
PyJWT
|
||||
half_orm @ git+ssh://git@gite.lirmm.fr/newsi/halfORM.git
|
||||
pygit2==0.28.2
|
||||
|
|
|
|||
|
|
@ -1 +0,0 @@
|
|||
http 127.0.0.1:3000/halfapi/whoami Authorization:$(http 127.0.0.1:3000/authentication/check email=malves password=papa|jq -r '.token')
|
||||
65
setup.py
65
setup.py
|
|
@ -8,9 +8,6 @@ from setuptools import setup, find_packages
|
|||
|
||||
import pathlib
|
||||
|
||||
here = pathlib.Path(__file__).parent.resolve()
|
||||
long_description = (here / 'README.md').read_text(encoding='utf-8')
|
||||
|
||||
def get_version(package):
|
||||
"""
|
||||
Return package version as listed in `__version__` in `init.py`.
|
||||
|
|
@ -19,6 +16,13 @@ def get_version(package):
|
|||
return re.search("__version__ = ['\"]([^'\"]+)['\"]", f.read()).group(1)
|
||||
|
||||
|
||||
def get_long_description():
|
||||
"""
|
||||
Return the README.
|
||||
"""
|
||||
here = pathlib.Path(__file__).parent.resolve()
|
||||
long_description = (here / 'README.md').read_text(encoding='utf-8')
|
||||
|
||||
def get_packages(package):
|
||||
"""
|
||||
Return root package and all sub-packages.
|
||||
|
|
@ -33,62 +37,27 @@ module_name="halfapi"
|
|||
setup(
|
||||
name=module_name,
|
||||
version=get_version(module_name),
|
||||
url="https://github.com/halfAPI/halfapi",
|
||||
description="Core to write deep APIs using a module's tree",
|
||||
author="Maxime ALVES",
|
||||
author_email="maxime@freepoteries.fr",
|
||||
license="GPLv3",
|
||||
long_description=long_description,
|
||||
url="https://gite.lirmm.fr/malves/halfapi",
|
||||
long_description=get_long_description(),
|
||||
long_description_content_type="text/markdown",
|
||||
packages=get_packages(module_name),
|
||||
python_requires=">=3.8",
|
||||
python_requires=">=3.7",
|
||||
install_requires=[
|
||||
"PyJWT>=2.6.0,<2.7.0",
|
||||
"starlette>=0.33,<0.34",
|
||||
"click>=8,<9",
|
||||
"uvicorn>=0.13,<1",
|
||||
"orjson>=3.8.5,<4",
|
||||
"pyyaml>=6,<7",
|
||||
"timing-asgi>=0.2.1,<1",
|
||||
"schema>=0.7.4,<1",
|
||||
"toml>=0.10,<0.11",
|
||||
"packaging>=19.0",
|
||||
"python-multipart"
|
||||
],
|
||||
classifiers=[
|
||||
"Development Status :: 3 - Alpha",
|
||||
"License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
|
||||
"Intended Audience :: Developers",
|
||||
"Topic :: Software Development :: Libraries :: Application Frameworks",
|
||||
"Programming Language :: Python :: 3.7",
|
||||
"Programming Language :: Python :: 3.8",
|
||||
"Programming Language :: Python :: 3.9",
|
||||
"Programming Language :: Python :: 3.10"
|
||||
"PyJWT>=1.7.1",
|
||||
"starlette>=0.13,<1",
|
||||
"half_orm @ git+ssh://git@gite.lirmm.fr/maizi/halfORM.git",
|
||||
"click>=7.1,<8",
|
||||
"uvicorn>=0.11,<1"
|
||||
],
|
||||
extras_require={
|
||||
"tests":[
|
||||
"pytest>=7,<8",
|
||||
"pytest-asyncio",
|
||||
"pylint",
|
||||
"requests",
|
||||
"httpx",
|
||||
"openapi-schema-validator",
|
||||
"openapi-spec-validator",
|
||||
"coverage"
|
||||
],
|
||||
"pyexcel":[
|
||||
"pyexcel",
|
||||
"pyexcel-ods3",
|
||||
"pyexcel-xlsx"
|
||||
"pytest",
|
||||
"requests"
|
||||
]
|
||||
},
|
||||
entry_points={
|
||||
"console_scripts":[
|
||||
"halfapi=halfapi.cli.cli:cli"
|
||||
]
|
||||
},
|
||||
keywords="web-api development boilerplate",
|
||||
project_urls={
|
||||
"Source": "https://github.com/halfAPI/halfapi",
|
||||
}
|
||||
)
|
||||
|
|
|
|||
|
|
@ -1,93 +0,0 @@
|
|||
#!/usr/bin/env python3
|
||||
import os
|
||||
import subprocess
|
||||
import importlib
|
||||
import tempfile
|
||||
from unittest.mock import patch
|
||||
|
||||
import pytest
|
||||
from click.testing import CliRunner
|
||||
from configparser import ConfigParser
|
||||
|
||||
from halfapi import __version__
|
||||
from halfapi.cli import cli
|
||||
Cli = cli.cli
|
||||
|
||||
PROJNAME = os.environ.get('PROJ','tmp_api')
|
||||
|
||||
|
||||
def test_options(runner):
|
||||
# Wrong command
|
||||
with runner.isolated_filesystem():
|
||||
r = runner.invoke(Cli, ['foobar'])
|
||||
assert r.exit_code == 2
|
||||
|
||||
# Test existing commands
|
||||
with runner.isolated_filesystem():
|
||||
r = runner.invoke(Cli, ['--help'])
|
||||
assert r.exit_code == 0
|
||||
|
||||
with runner.isolated_filesystem():
|
||||
r = runner.invoke(Cli, ['--version'])
|
||||
assert r.exit_code == 0
|
||||
|
||||
with runner.isolated_filesystem():
|
||||
r = runner.invoke(Cli, ['init', '--help'])
|
||||
assert r.exit_code == 0
|
||||
|
||||
|
||||
@pytest.mark.skip
|
||||
def test_init_project_fail(runner):
|
||||
# Missing argument (project)
|
||||
testproject = 'testproject'
|
||||
r = runner.invoke(Cli, ['init'])
|
||||
assert r.exit_code == 2
|
||||
|
||||
with runner.isolated_filesystem():
|
||||
# Fail : Wrong project name
|
||||
r = runner.invoke(Cli, ['init', 'test*-project'])
|
||||
assert r.exit_code == 1
|
||||
|
||||
with runner.isolated_filesystem():
|
||||
# Fail : Already existing folder
|
||||
os.mkdir(testproject)
|
||||
r = runner.invoke(Cli, ['init', testproject])
|
||||
assert r.exit_code == 1
|
||||
|
||||
with runner.isolated_filesystem():
|
||||
# Fail : Already existing nod
|
||||
os.mknod(testproject)
|
||||
r = runner.invoke(Cli, ['init', testproject])
|
||||
assert r.exit_code == 1
|
||||
|
||||
@pytest.mark.skip
|
||||
def test_init_project(runner):
|
||||
"""
|
||||
"""
|
||||
cp = ConfigParser()
|
||||
with runner.isolated_filesystem():
|
||||
env = {
|
||||
'HALFAPI_CONF_DIR': '.halfapi'
|
||||
}
|
||||
|
||||
res = runner.invoke(Cli, ['init', PROJNAME], env=env)
|
||||
try:
|
||||
assert os.path.isdir(PROJNAME)
|
||||
assert os.path.isdir(os.path.join(PROJNAME, '.halfapi'))
|
||||
|
||||
|
||||
# .halfapi/config check
|
||||
assert os.path.isfile(os.path.join(PROJNAME, '.halfapi', 'config'))
|
||||
cp.read(os.path.join(PROJNAME, '.halfapi', 'config'))
|
||||
assert cp.has_section('project')
|
||||
assert cp.has_option('project', 'name')
|
||||
assert cp.get('project', 'name') == PROJNAME
|
||||
assert cp.get('project', 'halfapi_version') == __version__
|
||||
# removal of domain section (0.6)
|
||||
# assert cp.has_section('domain')
|
||||
except AssertionError as exc:
|
||||
subprocess.run(['tree', '-a', os.getcwd()])
|
||||
raise exc
|
||||
|
||||
assert res.exit_code == 0
|
||||
assert res.exception is None
|
||||
|
|
@ -1,9 +0,0 @@
|
|||
from halfapi.cli.cli import cli
|
||||
from configparser import ConfigParser
|
||||
|
||||
def test_config(cli_runner):
|
||||
with cli_runner.isolated_filesystem():
|
||||
result = cli_runner.invoke(cli, ['config'])
|
||||
cp = ConfigParser()
|
||||
cp.read_string(result.output)
|
||||
assert cp.has_section('project')
|
||||
|
|
@ -1,84 +0,0 @@
|
|||
#!/usr/bin/env python3
|
||||
import os
|
||||
import subprocess
|
||||
import importlib
|
||||
import tempfile
|
||||
from unittest.mock import patch
|
||||
import json
|
||||
import toml
|
||||
|
||||
import pytest
|
||||
from click.testing import CliRunner
|
||||
from configparser import ConfigParser
|
||||
from halfapi.conf import DEFAULT_CONF, PROJECT_LEVEL_KEYS, DOMAIN_LEVEL_KEYS
|
||||
|
||||
PROJNAME = os.environ.get('PROJ','tmp_api')
|
||||
|
||||
|
||||
class TestCliProj():
|
||||
def test_cmds(self, project_runner):
|
||||
assert project_runner('--help').exit_code == 0
|
||||
#assert project_runner('run', '--help').exit_code == 0
|
||||
#assert project_runner('domain', '--help').exit_code == 0
|
||||
|
||||
|
||||
def test_domain_commands(self, project_runner):
|
||||
""" TODO: Test create command
|
||||
"""
|
||||
test_conf = {
|
||||
'project': {
|
||||
'port': '3010',
|
||||
'loglevel': 'warning'
|
||||
},
|
||||
'domain': {
|
||||
'dummy_domain': {
|
||||
'port': 4242,
|
||||
'name': 'dummy_domain',
|
||||
'enabled': True
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
r = project_runner('domain')
|
||||
print(r.stdout)
|
||||
assert r.exit_code == 1
|
||||
_, tmp_conf = tempfile.mkstemp()
|
||||
with open(tmp_conf, 'w') as fh:
|
||||
fh.write(
|
||||
toml.dumps(test_conf)
|
||||
)
|
||||
|
||||
r = project_runner(f'domain dummy_domain --conftest {tmp_conf}')
|
||||
assert r.exit_code == 0
|
||||
r_conf = toml.loads(r.stdout)
|
||||
for key, value in r_conf.items():
|
||||
if key == 'domain':
|
||||
continue
|
||||
assert key in PROJECT_LEVEL_KEYS
|
||||
if key == 'port':
|
||||
assert value == test_conf['domain']['dummy_domain']['port']
|
||||
elif key == 'loglevel':
|
||||
assert value == test_conf['project']['loglevel']
|
||||
else:
|
||||
assert value == DEFAULT_CONF[key.upper()]
|
||||
|
||||
|
||||
assert json.dumps(test_conf['domain']) == json.dumps(r_conf['domain'])
|
||||
|
||||
for key in test_conf['domain']['dummy_domain'].keys():
|
||||
assert key in DOMAIN_LEVEL_KEYS
|
||||
|
||||
# Default command "run"
|
||||
r = project_runner(f'domain dummy_domain --dry-run {tmp_conf}')
|
||||
print(r.stdout)
|
||||
assert r.exit_code == 0
|
||||
|
||||
|
||||
def test_config_commands(self, project_runner):
|
||||
try:
|
||||
r = project_runner('config')
|
||||
assert r.exit_code == 0
|
||||
except AssertionError as exc:
|
||||
subprocess.call(['tree', '-a'])
|
||||
raise exc
|
||||
|
||||
|
|
@ -1,33 +0,0 @@
|
|||
import pytest
|
||||
from click.testing import CliRunner
|
||||
from halfapi.cli.cli import cli
|
||||
import os
|
||||
from unittest.mock import patch
|
||||
|
||||
|
||||
@pytest.mark.skip
|
||||
def test_run_noproject(cli_runner):
|
||||
with cli_runner.isolated_filesystem():
|
||||
result = cli_runner.invoke(cli, ['config'])
|
||||
print(result.stdout)
|
||||
assert result.exit_code == 0
|
||||
|
||||
result = cli_runner.invoke(cli, ['run', '--dryrun'])
|
||||
try:
|
||||
assert result.exit_code == 0
|
||||
except AssertionError as exc:
|
||||
print(result.stdout)
|
||||
raise exc
|
||||
|
||||
"""
|
||||
def test_run_empty_project(cli_runner):
|
||||
with cli_runner.isolated_filesystem():
|
||||
os.mkdir('dummy_domain')
|
||||
result = cli_runner.invoke(cli, ['run', './dummy_domain'])
|
||||
assert result.exit_code == 1
|
||||
|
||||
def test_run_dummy_project(project_runner):
|
||||
with patch('uvicorn.run', autospec=True) as runMock:
|
||||
result = project_runner.invoke(cli, ['run'])
|
||||
runMock.assert_called_once()
|
||||
"""
|
||||
|
|
@ -1,120 +1,57 @@
|
|||
#!/usr/bin/env python3
|
||||
import logging
|
||||
import functools
|
||||
import re
|
||||
import os
|
||||
import subprocess
|
||||
import importlib
|
||||
import tempfile
|
||||
from typing import Dict, Tuple
|
||||
from uuid import uuid1, uuid4, UUID
|
||||
from click.testing import CliRunner
|
||||
import jwt
|
||||
import sys
|
||||
from unittest.mock import patch
|
||||
from typing import Dict, Tuple
|
||||
import pytest
|
||||
from starlette.applications import Starlette
|
||||
from starlette.responses import PlainTextResponse
|
||||
from starlette.middleware.authentication import AuthenticationMiddleware
|
||||
from starlette.testclient import TestClient
|
||||
from uuid import uuid1
|
||||
from click.testing import CliRunner
|
||||
from halfapi import __version__
|
||||
from halfapi.halfapi import HalfAPI
|
||||
from halfapi.cli.cli import cli
|
||||
from halfapi.cli.init import init
|
||||
from halfapi.cli.domain import domain, create_domain
|
||||
from halfapi.lib.responses import ORJSONResponse
|
||||
from halfapi.lib.jwt_middleware import JWTAuthenticationBackend
|
||||
|
||||
logger = logging.getLogger()
|
||||
from halfapi.cli import cli
|
||||
from halfapi.cli.init import format_halfapi_etc
|
||||
Cli = cli.cli
|
||||
|
||||
PROJNAME = os.environ.get('PROJ','tmp_api')
|
||||
|
||||
SECRET = 'dummysecret'
|
||||
|
||||
from halfapi.lib.jwt_middleware import (
|
||||
JWTUser, JWTAuthenticationBackend,
|
||||
JWTWebSocketAuthenticationBackend)
|
||||
|
||||
@pytest.fixture
|
||||
def dummy_domain():
|
||||
yield {
|
||||
'name': 'dummy_domain',
|
||||
'router': '.routers',
|
||||
'enabled': True,
|
||||
'prefix': False,
|
||||
'config': {
|
||||
'test': True
|
||||
}
|
||||
}
|
||||
|
||||
@pytest.fixture
|
||||
def token_builder():
|
||||
yield jwt.encode({
|
||||
'name':'xxx',
|
||||
'user_id': str(uuid4())},
|
||||
key=SECRET
|
||||
)
|
||||
|
||||
@pytest.fixture
|
||||
def token_debug_false_builder():
|
||||
yield jwt.encode({
|
||||
'name':'xxx',
|
||||
'user_id': str(uuid4()),
|
||||
'debug': False},
|
||||
key=SECRET
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def token_debug_true_builder():
|
||||
yield jwt.encode({
|
||||
'name':'xxx',
|
||||
'user_id': str(uuid4()),
|
||||
'debug': True},
|
||||
key=SECRET
|
||||
)
|
||||
|
||||
@pytest.fixture
|
||||
def runner():
|
||||
return CliRunner(mix_stderr=False)
|
||||
return CliRunner()
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def cli_runner():
|
||||
"""Yield a click.testing.CliRunner to invoke the CLI."""
|
||||
class_ = CliRunner
|
||||
def dropdb():
|
||||
p = subprocess.Popen(['dropdb', f'halfapi_{PROJNAME}'])
|
||||
p.wait()
|
||||
yield
|
||||
|
||||
def invoke_wrapper(f):
|
||||
"""Augment CliRunner.invoke to emit its output to stdout.
|
||||
|
||||
This enables pytest to show the output in its logs on test
|
||||
failures.
|
||||
|
||||
"""
|
||||
@functools.wraps(f)
|
||||
def wrapper(*args, **kwargs):
|
||||
echo = kwargs.pop('echo', False)
|
||||
result = f(*args, **kwargs)
|
||||
|
||||
if echo is True:
|
||||
sys.stdout.write(result.output)
|
||||
|
||||
return result
|
||||
|
||||
return wrapper
|
||||
|
||||
class_.invoke = invoke_wrapper(class_.invoke)
|
||||
cli_runner_ = class_(mix_stderr=False)
|
||||
|
||||
yield cli_runner_
|
||||
p = subprocess.Popen(['dropdb', f'halfapi_{PROJNAME}'])
|
||||
p.wait()
|
||||
|
||||
@pytest.fixture
|
||||
def halfapicli(cli_runner):
|
||||
def caller(*args):
|
||||
return cli_runner.invoke(cli, ' '.join(args))
|
||||
def createdb():
|
||||
p = subprocess.Popen(['createdb', f'halfapi_{PROJNAME}'])
|
||||
p.wait()
|
||||
return
|
||||
|
||||
yield caller
|
||||
def confdir(dirname):
|
||||
d = os.environ.get(dirname)
|
||||
if not d:
|
||||
os.environ[dirname] = tempfile.mkdtemp(prefix='halfapi_')
|
||||
return os.environ.get(dirname)
|
||||
if not os.path.isdir(d):
|
||||
os.mkdir(d)
|
||||
return d
|
||||
|
||||
@pytest.fixture
|
||||
def halform_conf_dir():
|
||||
return confdir('HALFORM_CONF_DIR')
|
||||
|
||||
@pytest.fixture
|
||||
def halfapi_conf_dir():
|
||||
return confdir('HALFAPI_CONF_DIR')
|
||||
|
||||
# store history of failures per test class name and per index in parametrize (if
|
||||
# parametrize used)
|
||||
|
|
@ -166,157 +103,26 @@ def pytest_runtest_setup(item):
|
|||
pytest.xfail("previous test failed ({})".format(test_name))
|
||||
|
||||
@pytest.fixture
|
||||
def project_runner(runner, halfapicli, tree):
|
||||
def project_runner(runner, dropdb, createdb, halform_conf_dir, halfapi_conf_dir):
|
||||
env = {
|
||||
'HALFORM_CONF_DIR': halform_conf_dir,
|
||||
'HALFAPI_CONF_DIR': halfapi_conf_dir
|
||||
}
|
||||
with runner.isolated_filesystem():
|
||||
res = halfapicli('init', PROJNAME)
|
||||
res = runner.invoke(Cli, ['init', PROJNAME],
|
||||
env=env,
|
||||
catch_exceptions=True)
|
||||
assert res.exit_code == 0
|
||||
|
||||
os.chdir(PROJNAME)
|
||||
|
||||
fs_path = os.getcwd()
|
||||
sys.path.insert(0, fs_path)
|
||||
|
||||
secret = tempfile.mkstemp()
|
||||
SECRET_PATH = secret[1]
|
||||
with open(SECRET_PATH, 'w') as f:
|
||||
f.write(str(uuid1()))
|
||||
|
||||
"""
|
||||
with open(os.path.join('.halfapi', PROJNAME), 'w') as halfapi_etc:
|
||||
with open(os.path.join(halfapi_conf_dir, PROJNAME), 'w') as f:
|
||||
PROJ_CONFIG = re.sub('secret = .*', f'secret = {SECRET_PATH}',
|
||||
format_halfapi_etc(PROJNAME, os.getcwd()))
|
||||
halfapi_etc.write(PROJ_CONFIG)
|
||||
"""
|
||||
f.write(PROJ_CONFIG)
|
||||
|
||||
|
||||
###
|
||||
# add dummy domain
|
||||
###
|
||||
create_domain('test_domain', 'test_domain.routers')
|
||||
###
|
||||
|
||||
yield halfapicli
|
||||
|
||||
while fs_path in sys.path:
|
||||
sys.path.remove(fs_path)
|
||||
|
||||
@pytest.fixture
|
||||
def dummy_app():
|
||||
app = Starlette()
|
||||
app.add_route('/',
|
||||
lambda request, *args, **kwargs: PlainTextResponse('Hello test!'))
|
||||
app.add_middleware(
|
||||
AuthenticationMiddleware,
|
||||
backend=JWTAuthenticationBackend(secret_key='dummysecret')
|
||||
)
|
||||
return app
|
||||
|
||||
@pytest.fixture
|
||||
def dummy_debug_app():
|
||||
app = Starlette(debug=True)
|
||||
app.add_route('/',
|
||||
lambda request, *args, **kwargs: PlainTextResponse('Hello test!'))
|
||||
app.add_middleware(
|
||||
AuthenticationMiddleware,
|
||||
backend=JWTAuthenticationBackend(secret_key='dummysecret')
|
||||
)
|
||||
return app
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def test_client(dummy_app):
|
||||
return TestClient(dummy_app)
|
||||
|
||||
@pytest.fixture
|
||||
def create_route():
|
||||
def wrapped(domain_path, method, path):
|
||||
stack = [domain_path, *path.split('/')[1:]]
|
||||
for i in range(len(stack)):
|
||||
if len(stack[i]) == 0:
|
||||
continue
|
||||
|
||||
path = os.path.join(*stack[0:i+1])
|
||||
if os.path.isdir(os.path.join(path)):
|
||||
continue
|
||||
os.mkdir(path)
|
||||
init_path = os.path.join(*stack, '__init__.py')
|
||||
with open(init_path, 'a+') as f:
|
||||
f.write(f'\ndef {method}():\n raise NotImplementedError')
|
||||
|
||||
return wrapped
|
||||
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def dummy_project():
|
||||
halfapi_config = tempfile.mktemp()
|
||||
halfapi_secret = tempfile.mktemp()
|
||||
domain = 'dummy_domain'
|
||||
|
||||
with open(halfapi_config, 'w') as f:
|
||||
f.writelines([
|
||||
'[project]\n',
|
||||
'name = lirmm_api\n',
|
||||
'halfapi_version = 0.5.0\n',
|
||||
f'secret = {halfapi_secret}\n',
|
||||
'port = 3050\n',
|
||||
'loglevel = debug\n',
|
||||
'[domain.dummy_domain]\n',
|
||||
f'name = {domain}\n',
|
||||
'router = dummy_domain.routers\n',
|
||||
f'[domain.dummy_domain.config]\n',
|
||||
'test = True'
|
||||
])
|
||||
|
||||
with open(halfapi_secret, 'w') as f:
|
||||
f.write('turlututu')
|
||||
|
||||
return (halfapi_config, 'dummy_domain', 'dummy_domain.routers')
|
||||
|
||||
@pytest.fixture
|
||||
def application_debug(project_runner):
|
||||
halfAPI = HalfAPI({
|
||||
'secret':'turlututu',
|
||||
'production':False,
|
||||
'domain': {
|
||||
'dummy_domain': {
|
||||
'name': 'dummy_domain',
|
||||
'router': '.routers',
|
||||
'enabled': True,
|
||||
'prefix': False,
|
||||
'config':{
|
||||
'test': True
|
||||
}
|
||||
}
|
||||
},
|
||||
})
|
||||
|
||||
assert isinstance(halfAPI, HalfAPI)
|
||||
yield halfAPI.application
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def application_domain(dummy_domain):
|
||||
return HalfAPI({
|
||||
'secret':'turlututu',
|
||||
'production':True,
|
||||
'domain': {
|
||||
'dummy_domain': {
|
||||
**dummy_domain,
|
||||
'config': {
|
||||
'test': True
|
||||
}
|
||||
}
|
||||
}
|
||||
}).application
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def tree():
|
||||
def wrapped(path):
|
||||
list_dirs = os.walk(path)
|
||||
for root, dirs, files in list_dirs:
|
||||
for d in dirs:
|
||||
print(os.path.join(root, d))
|
||||
for f in files:
|
||||
print(os.path.join(root, f))
|
||||
return wrapped
|
||||
yield lambda args: runner.invoke(Cli, args, env=env)
|
||||
|
|
|
|||
|
|
@ -1,27 +0,0 @@
|
|||
from halfapi import __version__ as halfapi_version
|
||||
|
||||
domain = {
|
||||
'name': 'dummy_domain',
|
||||
'version': '0.0.0',
|
||||
'id': '8b88e60a625369235b36c2d6d70756a0c02c1c7fb169fcee6dc820bcf9723f5a',
|
||||
'deps': (
|
||||
('halfapi', '=={}'.format(halfapi_version)),
|
||||
),
|
||||
'schema_components': {
|
||||
'schemas': {
|
||||
'Pinnochio': {
|
||||
'type': 'object',
|
||||
'required': {
|
||||
'id',
|
||||
'name',
|
||||
'nose_size'
|
||||
},
|
||||
'properties': {
|
||||
'id': {'type': 'string'},
|
||||
'name': {'type': 'string'},
|
||||
'nose_size': {'type': 'number'}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1,13 +0,0 @@
|
|||
from halfapi.lib import acl
|
||||
from halfapi.lib.acl import public, private, ACLS
|
||||
from random import randint
|
||||
|
||||
def random(*args):
|
||||
""" Random access ACL
|
||||
"""
|
||||
return randint(0,1) == 1
|
||||
|
||||
ACLS = (
|
||||
*ACLS,
|
||||
('random', random.__doc__, 10)
|
||||
)
|
||||
|
|
@ -1,59 +0,0 @@
|
|||
from halfapi.lib import acl
|
||||
from halfapi.lib.responses import ORJSONResponse
|
||||
ACLS = {
|
||||
'GET': [{'acl':acl.public}],
|
||||
'POST': [{'acl':acl.public}],
|
||||
'PATCH': [{'acl':acl.public}],
|
||||
'PUT': [{'acl':acl.public}],
|
||||
'DELETE': [{'acl':acl.public}]
|
||||
}
|
||||
|
||||
async def get(test):
|
||||
"""
|
||||
description:
|
||||
returns the path parameter
|
||||
responses:
|
||||
200:
|
||||
description: test response
|
||||
"""
|
||||
return ORJSONResponse(str(test))
|
||||
|
||||
def post(test):
|
||||
"""
|
||||
description:
|
||||
returns the path parameter
|
||||
responses:
|
||||
200:
|
||||
description: test response
|
||||
"""
|
||||
return str(test)
|
||||
|
||||
def patch(test):
|
||||
"""
|
||||
description:
|
||||
returns the path parameter
|
||||
responses:
|
||||
200:
|
||||
description: test response
|
||||
"""
|
||||
return str(test)
|
||||
|
||||
def put(test):
|
||||
"""
|
||||
description:
|
||||
returns the path parameter
|
||||
responses:
|
||||
200:
|
||||
description: test response
|
||||
"""
|
||||
return str(test)
|
||||
|
||||
def delete(test):
|
||||
"""
|
||||
description:
|
||||
returns the path parameter
|
||||
responses:
|
||||
200:
|
||||
description: test response
|
||||
"""
|
||||
return str(test)
|
||||
|
|
@ -1,14 +0,0 @@
|
|||
from starlette.responses import PlainTextResponse
|
||||
from halfapi.lib import acl
|
||||
|
||||
ACLS = {
|
||||
'GET': [{'acl':acl.public}]
|
||||
}
|
||||
|
||||
async def get(request, *args, **kwargs):
|
||||
"""
|
||||
responses:
|
||||
200:
|
||||
description: dummy abc.alphabet route
|
||||
"""
|
||||
return PlainTextResponse('True')
|
||||
|
|
@ -1,21 +0,0 @@
|
|||
from uuid import uuid4
|
||||
from halfapi.lib import acl
|
||||
ACLS = {
|
||||
'GET' : [{'acl':acl.public}]
|
||||
}
|
||||
def get():
|
||||
"""
|
||||
description: The pinnochio guy
|
||||
responses:
|
||||
200:
|
||||
description: test response
|
||||
content:
|
||||
application/json:
|
||||
schema:
|
||||
$ref: "#/components/schemas/Pinnochio"
|
||||
"""
|
||||
return {
|
||||
'id': str(uuid4()),
|
||||
'name': 'pinnochio',
|
||||
'nose_size': 42
|
||||
}
|
||||
|
|
@ -1,79 +0,0 @@
|
|||
from ... import acl
|
||||
from halfapi.logging import logger
|
||||
|
||||
ACLS = {
|
||||
'GET' : [
|
||||
{
|
||||
'acl':acl.public,
|
||||
'args': {
|
||||
'required': {
|
||||
'foo', 'bar'
|
||||
},
|
||||
'optional': {
|
||||
'x'
|
||||
}
|
||||
}
|
||||
|
||||
},
|
||||
{
|
||||
'acl':acl.random,
|
||||
'args': {
|
||||
'required': {
|
||||
'foo', 'baz'
|
||||
},
|
||||
'optional': {
|
||||
'truebidoo'
|
||||
}
|
||||
}
|
||||
},
|
||||
],
|
||||
'POST' : [
|
||||
{
|
||||
'acl':acl.private,
|
||||
'args': {
|
||||
'required': {
|
||||
'foo', 'bar'
|
||||
},
|
||||
'optional': {
|
||||
'x'
|
||||
}
|
||||
}
|
||||
|
||||
},
|
||||
{
|
||||
'acl':acl.public,
|
||||
'args': {
|
||||
'required': {
|
||||
'foo', 'baz'
|
||||
},
|
||||
'optional': {
|
||||
'truebidoo',
|
||||
'z'
|
||||
}
|
||||
}
|
||||
},
|
||||
]
|
||||
|
||||
}
|
||||
|
||||
def get(data):
|
||||
"""
|
||||
description:
|
||||
returns the arguments passed in
|
||||
responses:
|
||||
200:
|
||||
description: test response
|
||||
"""
|
||||
logger.error('%s', data['foo'])
|
||||
return data
|
||||
|
||||
def post(data):
|
||||
"""
|
||||
description:
|
||||
returns the arguments passed in
|
||||
responses:
|
||||
200:
|
||||
description: test response
|
||||
"""
|
||||
logger.error('%s', data)
|
||||
return data
|
||||
|
|
@ -1,69 +0,0 @@
|
|||
from halfapi.lib.responses import ORJSONResponse, NotImplementedResponse
|
||||
from ... import acl
|
||||
|
||||
ROUTES = {
|
||||
'abc/alphabet/{test:uuid}': {
|
||||
'GET': [{'acl': acl.public}]
|
||||
},
|
||||
'abc/pinnochio': {
|
||||
'GET': [{'acl': acl.public}]
|
||||
},
|
||||
'config': {
|
||||
'GET': [{'acl': acl.public}]
|
||||
},
|
||||
'arguments': {
|
||||
'GET': [{
|
||||
'acl': acl.public,
|
||||
'args': {
|
||||
'required': {'foo', 'bar'},
|
||||
'optional': set()
|
||||
}
|
||||
}]
|
||||
},
|
||||
}
|
||||
|
||||
async def get_abc_alphabet_TEST(request, *args, **kwargs):
|
||||
"""
|
||||
description: Not implemented
|
||||
responses:
|
||||
200:
|
||||
description: test response
|
||||
parameters:
|
||||
- name: test
|
||||
in: path
|
||||
description: Test parameter in route with "ROUTES" constant
|
||||
required: true
|
||||
schema:
|
||||
type: string
|
||||
"""
|
||||
return NotImplementedResponse()
|
||||
|
||||
async def get_abc_pinnochio(request, *args, **kwargs):
|
||||
"""
|
||||
description: Not implemented
|
||||
responses:
|
||||
200:
|
||||
description: test response
|
||||
"""
|
||||
return NotImplementedResponse()
|
||||
|
||||
async def get_config(request, *args, **kwargs):
|
||||
"""
|
||||
description: Not implemented
|
||||
responses:
|
||||
200:
|
||||
description: test response
|
||||
"""
|
||||
return NotImplementedResponse()
|
||||
|
||||
async def get_arguments(request, *args, **kwargs):
|
||||
"""
|
||||
description: Liste des datatypes.
|
||||
responses:
|
||||
200:
|
||||
description: test response
|
||||
"""
|
||||
return ORJSONResponse({
|
||||
'foo': kwargs.get('data').get('foo'),
|
||||
'bar': kwargs.get('data').get('bar')
|
||||
})
|
||||
|
|
@ -1,33 +0,0 @@
|
|||
from ... import acl
|
||||
from halfapi.logging import logger
|
||||
|
||||
ACLS = {
|
||||
'GET' : [
|
||||
{'acl':acl.public},
|
||||
{'acl':acl.random},
|
||||
]
|
||||
}
|
||||
|
||||
def get(halfapi):
|
||||
"""
|
||||
description:
|
||||
returns the configuration of the domain
|
||||
responses:
|
||||
200:
|
||||
description: test response
|
||||
"""
|
||||
logger.error('%s', halfapi)
|
||||
# TODO: Remove in 0.7.0
|
||||
try:
|
||||
assert 'test' in halfapi['config']['domain']['dummy_domain']['config']
|
||||
except AssertionError as exc:
|
||||
logger.error('No TEST in halfapi[config][domain][dummy_domain][config]')
|
||||
raise exc
|
||||
|
||||
try:
|
||||
assert 'test' in halfapi['config']
|
||||
except AssertionError as exc:
|
||||
logger.error('No TEST in halfapi[config]')
|
||||
raise exc
|
||||
|
||||
return halfapi['config']
|
||||
|
|
@ -1,8 +0,0 @@
|
|||
param_docstring = """
|
||||
name: second
|
||||
in: path
|
||||
description: second parameter description test
|
||||
required: true
|
||||
schema:
|
||||
type: string
|
||||
"""
|
||||
|
|
@ -1,20 +0,0 @@
|
|||
from uuid import UUID
|
||||
from halfapi.lib import acl
|
||||
ACLS = {
|
||||
'GET': [{'acl': acl.public}]
|
||||
}
|
||||
|
||||
def get(first, second, third):
|
||||
"""
|
||||
description: a Test route for path parameters
|
||||
responses:
|
||||
200:
|
||||
description: The test passed!
|
||||
500:
|
||||
description: The test did not pass :(
|
||||
"""
|
||||
assert isintance(first, str)
|
||||
assert isintance(second, UUID)
|
||||
assert isintance(third, int)
|
||||
|
||||
return ''
|
||||
|
|
@ -1,13 +0,0 @@
|
|||
from halfapi.lib import acl
|
||||
|
||||
ACLS = {
|
||||
'GET': [{'acl':acl.public}]
|
||||
}
|
||||
|
||||
def get(ext, ret_type='html'):
|
||||
"""
|
||||
responses:
|
||||
200:
|
||||
description: dummy abc.alphabet route
|
||||
"""
|
||||
return '\n'.join(('trololo', '', 'ololotr'))
|
||||
|
|
@ -1,31 +0,0 @@
|
|||
from halfapi.lib import acl
|
||||
|
||||
ACLS = {
|
||||
'GET': [{'acl':acl.public}],
|
||||
'POST': [
|
||||
{
|
||||
'acl':acl.public,
|
||||
'args': {
|
||||
'required': {'trou'},
|
||||
'optional': {'troo'}
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
|
||||
def get(ext, halfapi={}, ret_type='html'):
|
||||
"""
|
||||
responses:
|
||||
200:
|
||||
description: dummy abc.alphabet route
|
||||
"""
|
||||
return '\n'.join(('trololo', '', 'ololotr'))
|
||||
|
||||
def post(ext, data={'troo': 'fidget'}, halfapi={}, ret_type='html'):
|
||||
"""
|
||||
responses:
|
||||
200:
|
||||
description: dummy abc.alphabet route
|
||||
"""
|
||||
print(data)
|
||||
return '\n'.join(('trololo', '', 'ololotr'))
|
||||
|
|
@ -1,13 +0,0 @@
|
|||
from halfapi.lib import acl
|
||||
|
||||
ACLS = {
|
||||
'GET': [{'acl':acl.public}]
|
||||
}
|
||||
|
||||
def get(ret_type='html'):
|
||||
"""
|
||||
responses:
|
||||
200:
|
||||
description: dummy abc.alphabet route
|
||||
"""
|
||||
return '\n'.join(('trololo', '', 'ololotr'))
|
||||
|
|
@ -1,4 +0,0 @@
|
|||
from . import get
|
||||
|
||||
def test_get():
|
||||
assert isinstance(get(), str)
|
||||
|
|
@ -1,25 +0,0 @@
|
|||
#!/usr/bin/env python3
|
||||
# -*- coding: utf-8 -*-
|
||||
import os
|
||||
|
||||
def get_packages(package):
|
||||
"""
|
||||
Return root package and all sub-packages.
|
||||
"""
|
||||
return [
|
||||
dirpath
|
||||
for dirpath, dirnames, filenames in os.walk(package)
|
||||
if os.path.exists(os.path.join(dirpath, "__init__.py"))
|
||||
]
|
||||
|
||||
|
||||
from setuptools import setup, find_packages
|
||||
module_name="dummy_domain"
|
||||
setup(
|
||||
name=module_name,
|
||||
version='0',
|
||||
url="https://gite.lirmm.fr/malves/halfapi",
|
||||
packages=get_packages(module_name),
|
||||
python_requires=">=3.7",
|
||||
install_requires=[]
|
||||
)
|
||||
|
|
@ -1,37 +0,0 @@
|
|||
import pytest
|
||||
from starlette.responses import PlainTextResponse
|
||||
from starlette.testclient import TestClient
|
||||
from halfapi.half_route import HalfRoute
|
||||
from halfapi.lib import acl
|
||||
|
||||
def test_acl_Check(dummy_app, token_debug_false_builder):
|
||||
"""
|
||||
A request with ?check should always return a 200 status code
|
||||
"""
|
||||
|
||||
@HalfRoute.acl_decorator(params=[{'acl':acl.public}])
|
||||
async def test_route_public(request, **kwargs):
|
||||
raise Exception('Should not raise')
|
||||
return PlainTextResponse('ok')
|
||||
|
||||
dummy_app.add_route('/test_public', test_route_public)
|
||||
test_client = TestClient(dummy_app)
|
||||
|
||||
resp = test_client.request('get', '/test_public?check')
|
||||
assert resp.status_code == 200
|
||||
|
||||
@HalfRoute.acl_decorator(params=[{'acl':acl.private}])
|
||||
async def test_route_private(request, **kwargs):
|
||||
raise Exception('Should not raise')
|
||||
return PlainTextResponse('ok')
|
||||
|
||||
dummy_app.add_route('/test_private', test_route_private)
|
||||
test_client = TestClient(dummy_app)
|
||||
|
||||
resp = test_client.request('get', '/test_private')
|
||||
assert resp.status_code == 401
|
||||
|
||||
resp = test_client.request('get', '/test_private?check')
|
||||
assert resp.status_code == 200
|
||||
|
||||
|
||||
|
|
@ -1,15 +0,0 @@
|
|||
import os
|
||||
from starlette.applications import Starlette
|
||||
from unittest.mock import MagicMock, patch
|
||||
from halfapi.halfapi import HalfAPI
|
||||
|
||||
from halfapi.lib.domain import NoDomainsException
|
||||
|
||||
def test_halfapi_dummy_domain(dummy_domain):
|
||||
with patch('starlette.applications.Starlette') as mock:
|
||||
mock.return_value = MagicMock()
|
||||
config = {}
|
||||
config['domain'] = {}
|
||||
config['domain'][dummy_domain['name']] = dummy_domain
|
||||
print(config)
|
||||
halfapi = HalfAPI(config)
|
||||
|
|
@ -0,0 +1,96 @@
|
|||
#!/usr/bin/env python3
|
||||
import os
|
||||
import subprocess
|
||||
import importlib
|
||||
import tempfile
|
||||
from unittest.mock import patch
|
||||
|
||||
import pytest
|
||||
from click.testing import CliRunner
|
||||
from configparser import ConfigParser
|
||||
|
||||
from halfapi import __version__
|
||||
from halfapi.cli import cli
|
||||
Cli = cli.cli
|
||||
|
||||
PROJNAME = os.environ.get('PROJ','tmp_api')
|
||||
|
||||
|
||||
@pytest.mark.incremental
|
||||
class TestCli():
|
||||
def test_options(self, runner, dropdb, createdb):
|
||||
# Wrong command
|
||||
with runner.isolated_filesystem():
|
||||
r = runner.invoke(Cli, ['foobar'])
|
||||
assert r.exit_code == 2
|
||||
|
||||
# Test existing commands
|
||||
with runner.isolated_filesystem():
|
||||
r = runner.invoke(Cli, ['--help'])
|
||||
assert r.exit_code == 0
|
||||
|
||||
with runner.isolated_filesystem():
|
||||
r = runner.invoke(Cli, ['--version'])
|
||||
assert r.exit_code == 0
|
||||
|
||||
with runner.isolated_filesystem():
|
||||
r = runner.invoke(Cli, ['init', '--help'])
|
||||
assert r.exit_code == 0
|
||||
|
||||
|
||||
def test_init_project_fail(self, runner, dropdb):
|
||||
# Missing argument (project)
|
||||
testproject = 'testproject'
|
||||
r = runner.invoke(Cli, ['init'])
|
||||
assert r.exit_code == 2
|
||||
|
||||
with runner.isolated_filesystem():
|
||||
# Fail : Wrong project name
|
||||
r = runner.invoke(Cli, ['init', 'test*-project'])
|
||||
assert r.exit_code == 1
|
||||
|
||||
with runner.isolated_filesystem():
|
||||
# Fail : Already existing folder
|
||||
os.mkdir(testproject)
|
||||
r = runner.invoke(Cli, ['init', testproject])
|
||||
assert r.exit_code == 1
|
||||
|
||||
with runner.isolated_filesystem():
|
||||
# Fail : Already existing nod
|
||||
os.mknod(testproject)
|
||||
r = runner.invoke(Cli, ['init', testproject])
|
||||
assert r.exit_code == 1
|
||||
|
||||
def test_init_project(self, runner, dropdb, createdb, halform_conf_dir, halfapi_conf_dir):
|
||||
cp = ConfigParser()
|
||||
with runner.isolated_filesystem():
|
||||
env = {
|
||||
'HALFORM_CONF_DIR': halform_conf_dir,
|
||||
'HALFAPI_CONF_DIR': halfapi_conf_dir
|
||||
}
|
||||
|
||||
res = runner.invoke(Cli, ['init', PROJNAME], env=env)
|
||||
try:
|
||||
assert os.path.isdir(PROJNAME)
|
||||
assert os.path.isdir(os.path.join(PROJNAME, '.halfapi'))
|
||||
|
||||
|
||||
# .halfapi/config check
|
||||
assert os.path.isfile(os.path.join(PROJNAME, '.halfapi', 'config'))
|
||||
cp.read(os.path.join(PROJNAME, '.halfapi', 'config'))
|
||||
assert cp.has_section('project')
|
||||
assert cp.has_option('project', 'name')
|
||||
assert cp.get('project', 'name') == PROJNAME
|
||||
assert cp.get('project', 'halfapi_version') == __version__
|
||||
|
||||
# .halfapi/domains check
|
||||
assert os.path.isfile(os.path.join(PROJNAME, '.halfapi', 'domains'))
|
||||
cp.read(os.path.join(PROJNAME, '.halfapi', 'domains'))
|
||||
assert cp.has_section('domains')
|
||||
except AssertionError as e:
|
||||
subprocess.run(['tree', '-a', os.getcwd()])
|
||||
raise e
|
||||
|
||||
assert res.exit_code == 0
|
||||
assert res.exception is None
|
||||
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
#!/usr/bin/env python3
|
||||
import os
|
||||
import subprocess
|
||||
import importlib
|
||||
import tempfile
|
||||
from unittest.mock import patch
|
||||
|
||||
import pytest
|
||||
from click.testing import CliRunner
|
||||
from configparser import ConfigParser
|
||||
|
||||
PROJNAME = os.environ.get('PROJ','tmp_api')
|
||||
|
||||
@pytest.fixture
|
||||
def subproc(project_runner):
|
||||
def caller(cmd):
|
||||
proc = subprocess.Popen(cmd.split(' '))
|
||||
return proc.wait()
|
||||
return caller
|
||||
|
||||
@pytest.mark.incremental
|
||||
class TestCliProj():
|
||||
def test_cmds(self, subproc):
|
||||
assert subproc('halfapi run --help') == 0
|
||||
assert subproc('halfapi domain --help') == 0
|
||||
|
||||
def test_config_commands(self, subproc):
|
||||
res = subproc('halfapi config pr00t')
|
||||
assert res == 2
|
||||
res = subproc('halfapi config --help')
|
||||
assert res == 0
|
||||
res = subproc('halfapi config')
|
||||
assert res == 0
|
||||
|
||||
def test_domain_commands(self, subproc):
|
||||
res = subproc('halfapi domain foobar')
|
||||
assert res == 2
|
||||
res = subproc('halfapi domain --help')
|
||||
assert res == 0
|
||||
|
||||
def test_domain_create(self, subproc):
|
||||
DOMNAME='tmp_domain'
|
||||
res = subproc(f'halfapi domain --create')
|
||||
assert res == 0
|
||||
|
|
@ -1,52 +0,0 @@
|
|||
from unittest import TestCase
|
||||
import sys
|
||||
import pytest
|
||||
from halfapi.halfapi import HalfAPI
|
||||
|
||||
class TestConf(TestCase):
|
||||
def setUp(self):
|
||||
self.args = {
|
||||
'domain': {
|
||||
'dummy_domain': {
|
||||
'name': 'dummy_domain',
|
||||
'router': '.routers',
|
||||
'enabled': True,
|
||||
'prefix': False,
|
||||
}
|
||||
}
|
||||
}
|
||||
def tearDown(self):
|
||||
pass
|
||||
|
||||
def test_conf_production_default(self):
|
||||
halfapi = HalfAPI({
|
||||
**self.args
|
||||
})
|
||||
assert halfapi.PRODUCTION is True
|
||||
|
||||
def test_conf_production_true(self):
|
||||
halfapi = HalfAPI({
|
||||
**self.args,
|
||||
'production': True,
|
||||
})
|
||||
assert halfapi.PRODUCTION is True
|
||||
|
||||
def test_conf_production_false(self):
|
||||
halfapi = HalfAPI({
|
||||
**self.args,
|
||||
'production': False,
|
||||
})
|
||||
assert halfapi.PRODUCTION is False
|
||||
|
||||
def test_conf_variables(self):
|
||||
from halfapi.conf import (
|
||||
CONFIG,
|
||||
SCHEMA,
|
||||
)
|
||||
|
||||
assert isinstance(CONFIG, dict)
|
||||
assert isinstance(CONFIG.get('project_name'), str)
|
||||
assert isinstance(SCHEMA, dict)
|
||||
assert isinstance(CONFIG.get('secret'), str)
|
||||
assert isinstance(CONFIG.get('host'), str)
|
||||
assert isinstance(CONFIG.get('port'), int)
|
||||
|
|
@ -1,14 +0,0 @@
|
|||
from schema import Schema
|
||||
def test_constants():
|
||||
from halfapi.lib.constants import (
|
||||
VERBS,
|
||||
ACLS_SCHEMA,
|
||||
ROUTE_SCHEMA,
|
||||
DOMAIN_SCHEMA,
|
||||
API_SCHEMA)
|
||||
|
||||
assert isinstance(VERBS, tuple)
|
||||
assert isinstance(ACLS_SCHEMA, Schema)
|
||||
assert isinstance(ROUTE_SCHEMA, Schema)
|
||||
assert isinstance(DOMAIN_SCHEMA, Schema)
|
||||
assert isinstance(API_SCHEMA, Schema)
|
||||
|
|
@ -2,66 +2,14 @@
|
|||
import pytest
|
||||
from starlette.authentication import UnauthenticatedUser
|
||||
from starlette.testclient import TestClient
|
||||
import subprocess
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
import pprint
|
||||
import openapi_spec_validator
|
||||
import logging
|
||||
logger = logging.getLogger()
|
||||
from halfapi.app import app
|
||||
|
||||
from halfapi.lib.constants import API_SCHEMA
|
||||
def test_itworks():
|
||||
c = TestClient(app)
|
||||
r = c.get('/')
|
||||
assert r.text == 'It Works!'
|
||||
|
||||
|
||||
def test_halfapi_whoami(application_debug):
|
||||
# @TODO : If we use isolated filesystem multiple times that creates a bug.
|
||||
# So we use a single function with fixture "application debug"
|
||||
|
||||
c = TestClient(application_debug)
|
||||
r = c.request('get', '/halfapi/whoami')
|
||||
def test_user():
|
||||
c = TestClient(app)
|
||||
r = c.get('/user')
|
||||
assert r.status_code == 200
|
||||
|
||||
def test_halfapi_log(application_debug):
|
||||
# @TODO : If we use isolated filesystem multiple times that creates a bug.
|
||||
# So we use a single function with fixture "application debug"
|
||||
|
||||
c = TestClient(application_debug)
|
||||
|
||||
r = c.request('get', '/halfapi/log')
|
||||
assert r.status_code == 200
|
||||
|
||||
def test_halfapi_error_400(application_debug):
|
||||
# @TODO : If we use isolated filesystem multiple times that creates a bug.
|
||||
# So we use a single function with fixture "application debug"
|
||||
|
||||
c = TestClient(application_debug)
|
||||
|
||||
r = c.request('get', '/halfapi/error/400')
|
||||
assert r.status_code == 400
|
||||
|
||||
def test_halfapi_error_404(application_debug):
|
||||
# @TODO : If we use isolated filesystem multiple times that creates a bug.
|
||||
# So we use a single function with fixture "application debug"
|
||||
|
||||
c = TestClient(application_debug)
|
||||
|
||||
r = c.request('get', '/halfapi/error/404')
|
||||
assert r.status_code == 404
|
||||
|
||||
def test_halfapi_error_500(application_debug):
|
||||
# @TODO : If we use isolated filesystem multiple times that creates a bug.
|
||||
# So we use a single function with fixture "application debug"
|
||||
|
||||
c = TestClient(application_debug)
|
||||
|
||||
r = c.request('get', '/halfapi/error/500')
|
||||
assert r.status_code == 500
|
||||
|
||||
def test_schema(application_debug):
|
||||
c = TestClient(application_debug)
|
||||
|
||||
r = c.request('get', '/')
|
||||
schema = r.json()
|
||||
assert isinstance(schema, dict)
|
||||
openapi_spec_validator.validate_spec(schema)
|
||||
|
|
|
|||
|
|
@ -1,106 +0,0 @@
|
|||
import pytest
|
||||
from halfapi.testing.test_domain import TestDomain
|
||||
from pprint import pprint
|
||||
import logging
|
||||
logger = logging.getLogger()
|
||||
|
||||
class TestDummyDomain(TestDomain):
|
||||
from .dummy_domain import domain
|
||||
__name__ = domain.get('name')
|
||||
__routers__ = domain.get('routers')
|
||||
|
||||
DOMAIN = __name__
|
||||
CONFIG = {'test': True}
|
||||
|
||||
def test_domain(self):
|
||||
self.check_domain()
|
||||
|
||||
def test_routes(self):
|
||||
self.check_routes()
|
||||
|
||||
def test_html_route(self):
|
||||
res = self.client.request('get', '/ret_type')
|
||||
assert res.status_code == 200
|
||||
assert isinstance(res.content.decode(), str)
|
||||
assert res.headers['content-type'].split(';')[0] == 'text/html'
|
||||
|
||||
res = self.client.request('get', '/ret_type/h24')
|
||||
assert res.status_code == 200
|
||||
assert isinstance(res.content.decode(), str)
|
||||
assert res.headers['content-type'].split(';')[0] == 'text/html'
|
||||
|
||||
res = self.client.request('get', '/ret_type/h24/config')
|
||||
assert res.status_code == 200
|
||||
assert isinstance(res.content.decode(), str)
|
||||
assert res.headers['content-type'].split(';')[0] == 'text/html'
|
||||
|
||||
res = self.client.request('post', '/ret_type/h24/config', json={
|
||||
'trou': 'glet'
|
||||
})
|
||||
assert res.status_code == 200
|
||||
assert isinstance(res.content.decode(), str)
|
||||
assert res.headers['content-type'].split(';')[0] == 'text/html'
|
||||
|
||||
def test_arguments__get_routes(self):
|
||||
res = self.client.request('post', '/arguments?foo=1&x=3')
|
||||
|
||||
assert res.status_code == 400
|
||||
|
||||
arg_dict = {'foo': '1', 'bar': '2', 'x': '3'}
|
||||
res = self.client.request('get', '/arguments?foo=1&bar=2&x=3')
|
||||
assert res.json() == arg_dict
|
||||
|
||||
res = self.client.request('get', '/arguments?foo=1&bar=2&x=3&y=4')
|
||||
assert res.json() == arg_dict
|
||||
|
||||
def test_arguments_post_routes(self):
|
||||
arg_dict = {}
|
||||
res = self.client.request('post', '/arguments', json=arg_dict)
|
||||
|
||||
assert res.status_code == 400
|
||||
|
||||
arg_dict = {'foo': '1', 'bar': '3'}
|
||||
res = self.client.request('post', '/arguments', json=arg_dict)
|
||||
|
||||
assert res.status_code == 400
|
||||
|
||||
arg_dict = {'foo': '1', 'baz': '3'}
|
||||
res = self.client.request('post', '/arguments', json=arg_dict)
|
||||
|
||||
assert res.json() == arg_dict
|
||||
|
||||
arg_dict = {'foo': '1', 'baz': '3', 'truebidoo': '4'}
|
||||
res = self.client.request('post', '/arguments', json=arg_dict)
|
||||
|
||||
assert res.json() == arg_dict
|
||||
|
||||
res = self.client.request('post', '/arguments', json={ **arg_dict, 'y': '4'})
|
||||
assert res.json() == arg_dict
|
||||
|
||||
res = self.client.request('post', '/arguments', json={ **arg_dict, 'z': True})
|
||||
assert res.json() == {**arg_dict, 'z': True}
|
||||
|
||||
def test_schema_path_params(self):
|
||||
res = self.client.request('get', '/halfapi/schema')
|
||||
schema = res.json()
|
||||
|
||||
logger.debug(schema)
|
||||
|
||||
assert len(schema['paths']) > 0
|
||||
route = schema['paths']['/path_params/{first}/one/{second}/two/{third}']
|
||||
|
||||
assert 'parameters' in route['get']
|
||||
parameters = route['get']['parameters']
|
||||
|
||||
assert len(parameters) == 3
|
||||
|
||||
param_map = {
|
||||
elt['name']: elt
|
||||
for elt in parameters
|
||||
}
|
||||
|
||||
assert param_map['second']['description'] == 'second parameter description test'
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
@ -1,19 +0,0 @@
|
|||
import importlib
|
||||
from halfapi.testing.test_domain import TestDomain
|
||||
|
||||
def test_dummy_domain():
|
||||
from . import dummy_domain
|
||||
from .dummy_domain import acl
|
||||
assert acl.public() is True
|
||||
assert isinstance(acl.random(), int)
|
||||
assert acl.private() is False
|
||||
|
||||
|
||||
from .dummy_domain import routers
|
||||
from .dummy_domain.routers.arguments import get
|
||||
from .dummy_domain.routers.abc.alphabet.TEST_uuid import get
|
||||
from .dummy_domain.routers.abc.pinnochio import get
|
||||
from .dummy_domain.routers.config import get
|
||||
from .dummy_domain.routers.config import get
|
||||
from .dummy_domain.routers import async_router
|
||||
from .dummy_domain.routers.async_router import ROUTES, get_abc_alphabet_TEST, get_abc_pinnochio, get_config, get_arguments
|
||||
|
|
@ -1,109 +0,0 @@
|
|||
import os
|
||||
import sys
|
||||
import importlib
|
||||
import subprocess
|
||||
import time
|
||||
import pytest
|
||||
import json
|
||||
from pprint import pprint
|
||||
from starlette.routing import Route
|
||||
from starlette.testclient import TestClient
|
||||
|
||||
def test_get_config_route(dummy_project, application_domain):
|
||||
c = TestClient(application_domain)
|
||||
r = c.request('get', '/')
|
||||
assert r.status_code == 200
|
||||
pprint(r.json())
|
||||
r = c.request('get', '/config')
|
||||
assert r.status_code == 200
|
||||
pprint(r.json())
|
||||
assert 'test' in r.json()
|
||||
|
||||
def test_get_route(dummy_project, application_domain):
|
||||
c = TestClient(application_domain)
|
||||
path = verb = params = None
|
||||
dummy_domain_routes = [
|
||||
('config','GET'),
|
||||
('config','GET'),
|
||||
('async_router/abc/pinnochio','GET'),
|
||||
('async_router/config','GET'),
|
||||
# ('abc/pinnochio','GET'),
|
||||
# ('abc/alphabet','GET'),
|
||||
]
|
||||
|
||||
for route_def in dummy_domain_routes:
|
||||
path, verb = route_def[0], route_def[1]
|
||||
route_path = '/{}'.format(path)
|
||||
print(route_path)
|
||||
try:
|
||||
if verb.lower() == 'get':
|
||||
r = c.request('get', route_path)
|
||||
elif verb.lower() == 'post':
|
||||
r = c.request('post', route_path)
|
||||
elif verb.lower() == 'patch':
|
||||
r = c.request('patch', route_path)
|
||||
elif verb.lower() == 'put':
|
||||
r = c.request('put', route_path)
|
||||
elif verb.lower() == 'delete':
|
||||
r = c.request('delete', route_path)
|
||||
else:
|
||||
raise Exception(verb)
|
||||
try:
|
||||
assert r.status_code in [200, 501]
|
||||
except AssertionError as exc:
|
||||
print('{} [{}] {}'.format(str(r.status_code), verb, route_path))
|
||||
raise exc from exc
|
||||
|
||||
except NotImplementedError:
|
||||
pass
|
||||
|
||||
dummy_domain_path_routes = [
|
||||
('abc/alphabet/{test}','GET'),
|
||||
]
|
||||
|
||||
#for route_def in dummy_domain_path_routes:
|
||||
for route_def in []:#dummy_domain_routes:
|
||||
from uuid import uuid4
|
||||
test_uuid = uuid4()
|
||||
for route_def in dummy_domain_path_routes:
|
||||
path, verb = route_def[0], route_def[1]
|
||||
path = path.format(test=str(test_uuid))
|
||||
route_path = f'/{path}'
|
||||
if verb.lower() == 'get':
|
||||
r = c.request('get', f'{route_path}')
|
||||
|
||||
assert r.status_code == 200
|
||||
|
||||
|
||||
def test_delete_route(dummy_project, application_domain):
|
||||
c = TestClient(application_domain)
|
||||
from uuid import uuid4
|
||||
arg = str(uuid4())
|
||||
r = c.request('delete', f'/abc/alphabet/{arg}')
|
||||
assert r.status_code == 200
|
||||
assert isinstance(r.json(), str)
|
||||
|
||||
def test_arguments_route(dummy_project, application_domain):
|
||||
c = TestClient(application_domain)
|
||||
|
||||
path = '/arguments'
|
||||
r = c.request('get', path)
|
||||
assert r.status_code == 400
|
||||
r = c.request('get', path, params={'foo':True})
|
||||
assert r.status_code == 400
|
||||
arg = {'foo':True, 'bar':True}
|
||||
r = c.request('get', path, params=arg)
|
||||
assert r.status_code == 200
|
||||
for key, val in arg.items():
|
||||
assert json.loads(r.json()[key]) == val
|
||||
path = '/async_router/arguments'
|
||||
r = c.request('get', path)
|
||||
assert r.status_code == 400
|
||||
r = c.request('get', path, params={'foo':True})
|
||||
assert r.status_code == 400
|
||||
arg = {'foo':True, 'bar':True}
|
||||
r = c.request('get', path, params=arg)
|
||||
assert r.status_code == 200
|
||||
for key, val in arg.items():
|
||||
assert json.loads(r.json()[key]) == val
|
||||
|
||||
|
|
@ -1,6 +0,0 @@
|
|||
from halfapi.halfapi import HalfAPI
|
||||
|
||||
def test_methods():
|
||||
assert 'application' in dir(HalfAPI)
|
||||
assert 'version' in dir(HalfAPI)
|
||||
assert 'version_async' in dir(HalfAPI)
|
||||
|
|
@ -14,12 +14,131 @@ from starlette.testclient import TestClient
|
|||
from starlette.authentication import (
|
||||
AuthenticationBackend, AuthenticationError, BaseUser, AuthCredentials,
|
||||
UnauthenticatedUser)
|
||||
from starlette.responses import PlainTextResponse
|
||||
|
||||
from halfapi.lib.jwt_middleware import (
|
||||
|
||||
#from halfapi.app import app
|
||||
os.environ['HALFAPI_PROD'] = 'True'
|
||||
os.environ['HALFAPI_SECRET'] = 'randomsecret'
|
||||
|
||||
from halfapi.lib.jwt_middleware import (PRODUCTION, SECRET,
|
||||
JWTUser, JWTAuthenticationBackend,
|
||||
JWTWebSocketAuthenticationBackend)
|
||||
|
||||
def test_constants():
|
||||
assert PRODUCTION == bool(os.environ['HALFAPI_PROD'])
|
||||
assert SECRET == os.environ['HALFAPI_SECRET']
|
||||
|
||||
@pytest.fixture
|
||||
def token():
|
||||
# This fixture needs to have a running auth-lirmm on 127.0.0.1:3000
|
||||
# Sets a valid token
|
||||
|
||||
r = requests.post('http://127.0.0.1:3000/',
|
||||
data={'email':'maizi', 'password':'a'})
|
||||
|
||||
if len(r.text) <= 0:
|
||||
raise Exception('No result in token retrieval')
|
||||
|
||||
try:
|
||||
res = json.loads(r.text)
|
||||
except JSONDecodeError:
|
||||
raise Exception('Malformed response from token retrieval')
|
||||
|
||||
if 'token' not in res.keys():
|
||||
raise Exception('Missing token in token request')
|
||||
|
||||
return res['token']
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def token_builder():
|
||||
yield jwt.encode({
|
||||
'name':'xxx',
|
||||
'id': str(uuid4())},
|
||||
key=SECRET
|
||||
)
|
||||
|
||||
@pytest.fixture
|
||||
def token_debug_false_builder():
|
||||
yield jwt.encode({
|
||||
'name':'xxx',
|
||||
'id': str(uuid4()),
|
||||
'debug': False},
|
||||
key=SECRET
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def token_debug_true_builder():
|
||||
yield jwt.encode({
|
||||
'name':'xxx',
|
||||
'id': str(uuid4()),
|
||||
'debug': True},
|
||||
key=SECRET
|
||||
)
|
||||
|
||||
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def token_dirser():
|
||||
# This fixture needs to have a running auth-lirmm on 127.0.0.1:3000
|
||||
# Sets a valid token
|
||||
|
||||
r = requests.post('http://127.0.0.1:3000/',
|
||||
data={'email':'dhenaut', 'password':'a'})
|
||||
|
||||
if len(r.text) <= 0:
|
||||
raise Exception('No result in token retrieval')
|
||||
|
||||
try:
|
||||
res = json.loads(r.text)
|
||||
except JSONDecodeError:
|
||||
raise Exception('Malformed response from token retrieval')
|
||||
|
||||
if 'token' not in res.keys():
|
||||
raise Exception('Missing token in token request')
|
||||
|
||||
return res['token']
|
||||
|
||||
|
||||
"""
|
||||
def test_token(token):
|
||||
client = TestClient(app)
|
||||
|
||||
r = client.get('/user', headers={'Authorization':token})
|
||||
res = False
|
||||
try:
|
||||
res = json.loads(r.text)
|
||||
except JSONDecodeError:
|
||||
raise Exception('Malformed response from /user request')
|
||||
|
||||
assert 'user' in res.keys()
|
||||
assert 'id' in res['user'].keys()
|
||||
assert 'token' in res['user'].keys()
|
||||
assert 'payload' in res['user'].keys()
|
||||
|
||||
def test_labopers(token, token_dirser):
|
||||
res = requests.get('http://127.0.0.1:8080/api/v4/organigramme/laboratoire/personnel',
|
||||
params={
|
||||
'q': 'limit:10|format:csv'
|
||||
},
|
||||
headers={
|
||||
'Authorization': token
|
||||
})
|
||||
|
||||
assert res.status_code == 401
|
||||
|
||||
res = requests.get('http://127.0.0.1:8080/api/v4/organigramme/laboratoire/personnel',
|
||||
params={
|
||||
'q': 'limit:10|format:csv'
|
||||
},
|
||||
headers={
|
||||
'Authorization': token_dirser
|
||||
})
|
||||
|
||||
assert res.status_code == 200
|
||||
"""
|
||||
|
||||
def test_JWTUser():
|
||||
uid = uuid4()
|
||||
|
|
@ -31,102 +150,47 @@ def test_JWTUser():
|
|||
assert user.payload == payload
|
||||
assert user.is_authenticated == True
|
||||
|
||||
def test_jwt_NoToken(dummy_app):
|
||||
async def test_route(request):
|
||||
assert isinstance(request.user, UnauthenticatedUser)
|
||||
return PlainTextResponse('ok')
|
||||
@pytest.mark.asyncio
|
||||
async def test_JWTAuthenticationBackend(token_builder):
|
||||
backend = JWTAuthenticationBackend()
|
||||
assert backend.secret_key == SECRET
|
||||
|
||||
dummy_app.add_route('/test', test_route)
|
||||
test_client = TestClient(dummy_app)
|
||||
resp = test_client.request('get', '/test')
|
||||
assert resp.status_code == 200
|
||||
|
||||
def test_jwt_Token(dummy_app, token_builder):
|
||||
async def test_route(request):
|
||||
assert isinstance(request.user, JWTUser)
|
||||
print(request.scope['app'].debug)
|
||||
return PlainTextResponse('ok')
|
||||
|
||||
dummy_app.add_route('/test', test_route)
|
||||
test_client = TestClient(dummy_app)
|
||||
|
||||
resp = test_client.request('get', '/test',
|
||||
cookies={
|
||||
'Authorization': token_builder
|
||||
})
|
||||
assert resp.status_code == 200
|
||||
|
||||
resp = test_client.request('get', '/test',
|
||||
req = Request(
|
||||
headers={
|
||||
'Authorization': token_builder
|
||||
})
|
||||
assert resp.status_code == 200
|
||||
|
||||
credentials, user = await backend.authenticate(req)
|
||||
assert type(user) == JWTUser
|
||||
assert type(credentials) == AuthCredentials
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_JWTAuthenticationBackend_DebugFalse(token_debug_false_builder):
|
||||
backend = JWTAuthenticationBackend()
|
||||
assert backend.secret_key == SECRET
|
||||
|
||||
def test_jwt_DebugFalse(dummy_app, token_debug_false_builder):
|
||||
async def test_route(request):
|
||||
assert isinstance(request.user, JWTUser)
|
||||
return PlainTextResponse('ok')
|
||||
|
||||
dummy_app.add_route('/test', test_route)
|
||||
test_client = TestClient(dummy_app)
|
||||
|
||||
resp = test_client.request('get', '/test',
|
||||
cookies={
|
||||
'Authorization': token_debug_false_builder
|
||||
})
|
||||
assert resp.status_code == 200
|
||||
|
||||
resp = test_client.request('get', '/test',
|
||||
req = Request(
|
||||
headers={
|
||||
'Authorization': token_debug_false_builder
|
||||
})
|
||||
assert resp.status_code == 200
|
||||
|
||||
credentials, user = await backend.authenticate(req)
|
||||
assert type(user) == JWTUser
|
||||
assert type(credentials) == AuthCredentials
|
||||
|
||||
|
||||
def test_jwt_DebugTrue(dummy_app, token_debug_true_builder):
|
||||
"""
|
||||
A debug token should return a 400 status code with a non debug app
|
||||
"""
|
||||
async def test_route(request):
|
||||
return PlainTextResponse('ok')
|
||||
@pytest.mark.asyncio
|
||||
async def test_JWTAuthenticationBackend_DebugTrue(token_debug_true_builder):
|
||||
backend = JWTAuthenticationBackend()
|
||||
assert backend.secret_key == SECRET
|
||||
|
||||
dummy_app.add_route('/test', test_route)
|
||||
test_client = TestClient(dummy_app)
|
||||
|
||||
resp = test_client.request('get', '/test',
|
||||
cookies={
|
||||
'Authorization': token_debug_true_builder
|
||||
})
|
||||
assert resp.status_code == 400
|
||||
|
||||
resp = test_client.request('get', '/test',
|
||||
req = Request(
|
||||
headers={
|
||||
'Authorization': token_debug_true_builder
|
||||
})
|
||||
assert resp.status_code == 400
|
||||
|
||||
|
||||
def test_jwt_DebugTrue_DebugApp(dummy_debug_app, token_debug_true_builder):
|
||||
"""
|
||||
A debug token should return a 200 status code with a debug app
|
||||
"""
|
||||
async def test_route(request):
|
||||
assert isinstance(request.user, JWTUser)
|
||||
return PlainTextResponse('ok')
|
||||
|
||||
dummy_debug_app.add_route('/test', test_route)
|
||||
test_client = TestClient(dummy_debug_app)
|
||||
|
||||
resp = test_client.request('get', '/test',
|
||||
cookies={
|
||||
'Authorization': token_debug_true_builder
|
||||
})
|
||||
assert resp.status_code == 200
|
||||
|
||||
resp = test_client.request('get', '/test',
|
||||
headers={
|
||||
'Authorization': token_debug_true_builder
|
||||
})
|
||||
assert resp.status_code == 200
|
||||
try:
|
||||
await backend.authenticate(req)
|
||||
except Exception as e:
|
||||
assert type(e) == AuthenticationError
|
||||
|
|
|
|||
|
|
@ -0,0 +1,54 @@
|
|||
import os
|
||||
import jwt
|
||||
from requests import Request
|
||||
import pytest
|
||||
from unittest.mock import patch
|
||||
import json
|
||||
from json.decoder import JSONDecodeError
|
||||
import sys
|
||||
from hashlib import sha256
|
||||
from base64 import b64decode
|
||||
from uuid import uuid4, UUID
|
||||
|
||||
from starlette.testclient import TestClient
|
||||
from starlette.authentication import (
|
||||
AuthenticationBackend, AuthenticationError, BaseUser, AuthCredentials,
|
||||
UnauthenticatedUser)
|
||||
|
||||
|
||||
#from halfapi.app import app
|
||||
os.environ['HALFAPI_PROD'] = ''
|
||||
os.environ['HALFAPI_SECRET'] = 'randomsecret'
|
||||
|
||||
from halfapi.lib.jwt_middleware import (PRODUCTION, SECRET,
|
||||
JWTUser, JWTAuthenticationBackend,
|
||||
JWTWebSocketAuthenticationBackend)
|
||||
|
||||
def test_constants():
|
||||
assert PRODUCTION == bool(os.environ['HALFAPI_PROD'])
|
||||
assert SECRET == os.environ['HALFAPI_SECRET']
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def token_debug_builder():
|
||||
yield jwt.encode({
|
||||
'name':'xxx',
|
||||
'id': str(uuid4()),
|
||||
'debug': True},
|
||||
key=SECRET
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_JWTAuthenticationBackend_debug(token_debug_builder):
|
||||
backend = JWTAuthenticationBackend()
|
||||
|
||||
req = Request(
|
||||
headers={
|
||||
'Authorization': token_debug_builder
|
||||
})
|
||||
|
||||
auth = await backend.authenticate(req)
|
||||
assert(len(auth) == 2)
|
||||
assert type(auth[0]) == AuthCredentials
|
||||
assert type(auth[1]) == JWTUser
|
||||
|
|
@ -1,124 +0,0 @@
|
|||
# #!/usr/bin/env python3
|
||||
# import importlib
|
||||
# from halfapi.lib.domain import VERBS, gen_routes, gen_router_routes, \
|
||||
# MissingAclError, domain_schema_dict, domain_schema_list
|
||||
#
|
||||
# from types import FunctionType
|
||||
#
|
||||
#
|
||||
# def test_gen_router_routes():
|
||||
# from .dummy_domain import routers
|
||||
# for path, verb, m_router, fct, params in gen_router_routes(routers, ['dummy_domain']):
|
||||
# assert isinstance(path, str)
|
||||
# assert verb in VERBS
|
||||
# assert len(params) > 0
|
||||
# assert hasattr(fct, '__call__')
|
||||
# assert len(m_router.__file__) > 0
|
||||
#
|
||||
#
|
||||
# def test_gen_routes():
|
||||
# from .dummy_domain.routers.abc.alphabet import TEST_uuid
|
||||
# try:
|
||||
# gen_routes(
|
||||
# TEST_uuid,
|
||||
# 'get',
|
||||
# ['abc', 'alphabet', 'TEST_uuid', ''],
|
||||
# [])
|
||||
# except MissingAclError:
|
||||
# assert True
|
||||
#
|
||||
# fct, params = gen_routes(
|
||||
# TEST_uuid,
|
||||
# 'get',
|
||||
# ['abc', 'alphabet', 'TEST_uuid', ''],
|
||||
# TEST_uuid.ACLS['GET'])
|
||||
#
|
||||
# assert isinstance(fct, FunctionType)
|
||||
# assert isinstance(params, list)
|
||||
# assert len(TEST_uuid.ACLS['GET']) == len(params)
|
||||
#
|
||||
# def test_domain_schema_dict():
|
||||
# from .dummy_domain import routers
|
||||
# d_res = domain_schema_dict(routers)
|
||||
#
|
||||
# assert isinstance(d_res, dict)
|
||||
#
|
||||
# def test_domain_schema_list():
|
||||
# from .dummy_domain import routers
|
||||
# res = domain_schema_list(routers)
|
||||
#
|
||||
# assert isinstance(res, list)
|
||||
# assert len(res) > 0
|
||||
|
||||
from starlette.testclient import TestClient
|
||||
from starlette.responses import Response
|
||||
from starlette.routing import Router, Route
|
||||
|
||||
from halfapi.lib.domain import route_decorator
|
||||
from halfapi.lib.user import Nobody
|
||||
|
||||
def test_route_decorator():
|
||||
""" It should decorate an async function that fullfills its arguments
|
||||
"""
|
||||
def route(halfapi, data, out, ret_type='txt'):
|
||||
for key in ['user', 'config', 'domain', 'cookies', 'base_url', 'url']:
|
||||
assert key in halfapi
|
||||
|
||||
assert halfapi['user'] is None
|
||||
assert isinstance(halfapi['config'], dict)
|
||||
assert len(halfapi['config']) == 0
|
||||
assert isinstance(halfapi['domain'], str)
|
||||
assert halfapi['domain'] == 'unknown'
|
||||
assert isinstance(halfapi['cookies'], dict)
|
||||
assert len(halfapi['cookies']) == 0
|
||||
assert len(str(halfapi['base_url'])) > 0
|
||||
assert str(halfapi['base_url']) == 'http://testserver/'
|
||||
assert len(str(halfapi['url'])) > 0
|
||||
assert str(halfapi['url']) == 'http://testserver/'
|
||||
assert isinstance(data, dict)
|
||||
assert len(data) == 0
|
||||
|
||||
assert out is None
|
||||
|
||||
assert ret_type is 'txt'
|
||||
|
||||
return ''
|
||||
|
||||
async_route = route_decorator(route)
|
||||
app = Router([Route('/', endpoint=async_route, methods=['GET'])])
|
||||
client = TestClient(app)
|
||||
response = client.get('/')
|
||||
assert response.is_success
|
||||
assert response.content.decode() == ''
|
||||
|
||||
def route(data, out, ret_type='txt'):
|
||||
assert isinstance(data, dict)
|
||||
assert len(data) == 0
|
||||
|
||||
assert out is None
|
||||
|
||||
assert ret_type is 'txt'
|
||||
|
||||
return ''
|
||||
|
||||
async_route = route_decorator(route)
|
||||
app = Router([Route('/', endpoint=async_route, methods=['GET'])])
|
||||
client = TestClient(app)
|
||||
response = client.get('/')
|
||||
assert response.is_success
|
||||
assert response.content.decode() == ''
|
||||
|
||||
def route(data):
|
||||
assert isinstance(data, dict)
|
||||
assert len(data) == 2
|
||||
assert data['toto'] == 'tata'
|
||||
assert data['bouboul'] == True
|
||||
|
||||
return ''
|
||||
|
||||
async_route = route_decorator(route)
|
||||
app = Router([Route('/', endpoint=async_route, methods=['POST'])])
|
||||
client = TestClient(app)
|
||||
response = client.post('/', json={'toto': 'tata', 'bouboul': True})
|
||||
assert response.is_success
|
||||
assert response.json() == ''
|
||||
|
|
@ -1,38 +0,0 @@
|
|||
from starlette.testclient import TestClient
|
||||
from starlette.middleware.base import BaseHTTPMiddleware
|
||||
from unittest.mock import patch
|
||||
from halfapi.lib.domain_middleware import DomainMiddleware
|
||||
|
||||
def test_init():
|
||||
with patch('starlette.middleware.base.BaseHTTPMiddleware.__init__') as init:
|
||||
mw = DomainMiddleware('app', 'domain')
|
||||
init.assert_called_once_with('app')
|
||||
assert mw.domain == 'domain'
|
||||
assert mw.request == None
|
||||
|
||||
def test_call(application_debug):
|
||||
c = TestClient(application_debug)
|
||||
r = c.request('get', '/abc/alphabet')
|
||||
assert r.status_code == 200
|
||||
assert r.headers['x-domain'] == 'dummy_domain'
|
||||
assert r.headers['x-acl'] == 'public'
|
||||
|
||||
r = c.request('get', '/arguments')
|
||||
assert r.status_code == 400
|
||||
assert r.headers['x-domain'] == 'dummy_domain'
|
||||
assert r.headers['x-acl'] == 'public'
|
||||
assert 'foo' in r.headers['x-args-required'].split(',')
|
||||
assert 'bar' in r.headers['x-args-required'].split(',')
|
||||
assert r.headers['x-args-optional'] == 'x'
|
||||
|
||||
c = TestClient(application_debug)
|
||||
r = c.request('post', '/arguments')
|
||||
assert r.status_code == 400
|
||||
assert r.headers['x-domain'] == 'dummy_domain'
|
||||
assert r.headers['x-acl'] == 'public'
|
||||
assert 'foo' in r.headers['x-args-required'].split(',')
|
||||
assert 'baz' in r.headers['x-args-required'].split(',')
|
||||
assert 'truebidoo' in r.headers['x-args-optional'].split(',')
|
||||
assert 'z' in r.headers['x-args-optional'].split(',')
|
||||
|
||||
|
||||
|
|
@ -1,62 +0,0 @@
|
|||
import json
|
||||
import decimal
|
||||
import datetime
|
||||
|
||||
from starlette.responses import Response
|
||||
from halfapi.lib.responses import *
|
||||
|
||||
def test_orjson():
|
||||
test_obj = {
|
||||
"ok": "ko",
|
||||
"dec": decimal.Decimal(42),
|
||||
"set": {0, 4, 2},
|
||||
"date": datetime.date(1,1,1),
|
||||
"datetime": datetime.datetime(1,1,1),
|
||||
}
|
||||
|
||||
resp = ORJSONResponse(test_obj)
|
||||
body = resp.body.decode()
|
||||
test_obj_dec = json.loads(body)
|
||||
print(test_obj_dec)
|
||||
assert 'ok' in test_obj_dec.keys()
|
||||
assert isinstance(test_obj_dec['ok'], str)
|
||||
assert isinstance(test_obj_dec['dec'], str)
|
||||
assert isinstance(test_obj_dec['set'], list)
|
||||
assert isinstance(test_obj_dec['date'], str)
|
||||
assert test_obj_dec['date'] == '0001-01-01'
|
||||
assert test_obj_dec['datetime'] == '0001-01-01T00:00:00'
|
||||
|
||||
|
||||
def test_responses():
|
||||
resp = HJSONResponse('')
|
||||
assert isinstance(resp, Response)
|
||||
assert resp.status_code == 200
|
||||
|
||||
resp = ORJSONResponse('')
|
||||
assert isinstance(resp, Response)
|
||||
assert resp.status_code == 200
|
||||
|
||||
resp = PlainTextResponse()
|
||||
assert isinstance(resp, Response)
|
||||
assert resp.status_code == 200
|
||||
|
||||
def test_errors():
|
||||
resp = ServiceUnavailableResponse()
|
||||
assert isinstance(resp, Response)
|
||||
assert resp.status_code == 503
|
||||
|
||||
resp = UnauthorizedResponse()
|
||||
assert isinstance(resp, Response)
|
||||
assert resp.status_code == 401
|
||||
|
||||
resp = InternalServerErrorResponse()
|
||||
assert isinstance(resp, Response)
|
||||
assert resp.status_code == 500
|
||||
|
||||
resp = NotFoundResponse()
|
||||
assert isinstance(resp, Response)
|
||||
assert resp.status_code == 404
|
||||
|
||||
resp = NotImplementedResponse()
|
||||
assert isinstance(resp, Response)
|
||||
assert resp.status_code == 501
|
||||
|
|
@ -1,57 +0,0 @@
|
|||
# import os
|
||||
# import pytest
|
||||
# from schema import SchemaError
|
||||
# from halfapi.lib.router import read_router
|
||||
# from halfapi.lib.constants import ROUTER_SCHEMA, ROUTER_ACLS_SCHEMA
|
||||
#
|
||||
# def test_read_router_routers():
|
||||
# from .dummy_domain import routers
|
||||
#
|
||||
# router_d = read_router(routers)
|
||||
# assert '' in router_d
|
||||
# assert 'SUBROUTES' in router_d['']
|
||||
# assert isinstance(router_d['']['SUBROUTES'], list)
|
||||
#
|
||||
# for elt in os.scandir(routers.__path__[0]):
|
||||
# if elt.is_dir():
|
||||
# assert elt.name in router_d['']['SUBROUTES']
|
||||
#
|
||||
# def test_read_router_abc():
|
||||
# from .dummy_domain.routers import abc
|
||||
# router_d = read_router(abc)
|
||||
#
|
||||
# assert '' in router_d
|
||||
# assert 'SUBROUTES' in router_d['']
|
||||
# assert isinstance(router_d['']['SUBROUTES'], list)
|
||||
#
|
||||
# def test_read_router_alphabet():
|
||||
# from .dummy_domain.routers.abc import alphabet
|
||||
# router_d = read_router(alphabet)
|
||||
#
|
||||
# assert '' in router_d
|
||||
# assert 'SUBROUTES' in router_d['']
|
||||
# assert isinstance(router_d['']['SUBROUTES'], list)
|
||||
#
|
||||
# ROUTER_SCHEMA.validate(router_d)
|
||||
#
|
||||
# with pytest.raises(SchemaError):
|
||||
# """ Test that we cannot specify wrong method in ROUTES or ACLS
|
||||
#
|
||||
# TODO: Write more errors
|
||||
# """
|
||||
# router_d['']['TEG'] = {}
|
||||
# ROUTER_SCHEMA.validate(router_d)
|
||||
#
|
||||
# def test_read_router_TEST():
|
||||
# from .dummy_domain.routers.abc.alphabet import TEST_uuid
|
||||
# router_d = read_router(TEST_uuid)
|
||||
#
|
||||
# print(router_d)
|
||||
# assert '' in router_d
|
||||
# assert 'SUBROUTES' in router_d['']
|
||||
# assert isinstance(router_d['']['GET'], list)
|
||||
# assert isinstance(router_d['']['POST'], list)
|
||||
# assert isinstance(router_d['']['PATCH'], list)
|
||||
# assert isinstance(router_d['']['PUT'], list)
|
||||
#
|
||||
#
|
||||
|
|
@ -1,34 +0,0 @@
|
|||
# from starlette.routing import Route
|
||||
# from halfapi.lib.routes import gen_starlette_routes, gen_router_routes
|
||||
#
|
||||
# def test_gen_starlette_routes():
|
||||
# from .dummy_domain import routers
|
||||
# for route in gen_starlette_routes({
|
||||
# 'dummy_domain': routers }):
|
||||
#
|
||||
# assert isinstance(route, Route)
|
||||
#
|
||||
# import pytest
|
||||
#
|
||||
# @pytest.mark.skip
|
||||
# def test_api_routes():
|
||||
# from . import dummy_domain
|
||||
# d_res, d_acls = api_routes(dummy_domain)
|
||||
# assert isinstance(d_res, dict)
|
||||
# assert isinstance(d_acls, dict)
|
||||
#
|
||||
# yielded = False
|
||||
#
|
||||
# for path, verb, m_router, fct, params in gen_router_routes(dummy_domain, []):
|
||||
# if not yielded:
|
||||
# yielded = True
|
||||
#
|
||||
# assert path in d_res
|
||||
# assert verb in d_res[path]
|
||||
# assert 'docs' in d_res[path][verb]
|
||||
# assert 'acls' in d_res[path][verb]
|
||||
# assert isinstance(d_res[path][verb]['docs'], dict)
|
||||
# assert isinstance(d_res[path][verb]['acls'], list)
|
||||
# assert len(d_res[path][verb]['acls']) == len(params)
|
||||
#
|
||||
# assert yielded is True
|
||||
Loading…
Reference in New Issue