diff options
Diffstat (limited to 'python-azf-wsgi.spec')
| -rw-r--r-- | python-azf-wsgi.spec | 307 |
1 files changed, 307 insertions, 0 deletions
diff --git a/python-azf-wsgi.spec b/python-azf-wsgi.spec new file mode 100644 index 0000000..923d101 --- /dev/null +++ b/python-azf-wsgi.spec @@ -0,0 +1,307 @@ +%global _empty_manifest_terminate_build 0 +Name: python-azf-wsgi +Version: 0.3.1 +Release: 1 +Summary: Azure Functions WSGI implementation [deprecated] +License: MIT License +URL: https://github.com/vtbassmatt/azf-wsgi +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/41/2a/839c624faee7d740e5d9f25da5dc61e98c3bd4a5f1cccca53121e48938be/azf-wsgi-0.3.1.tar.gz +BuildArch: noarch + +Requires: python3-azure-functions + +%description +This was an adapter package to let you run WSGI apps (Django, Flask, etc.) on Azure Functions. +Example: +```python +import azure.functions as func +# note that the package is "azf-wsgi" but the import is "azf_wsgi" +from azf_wsgi import AzureFunctionsWsgi +# Django, for example, but works with any WSGI app +from my_django_app.wsgi import application +def main(req: func.HttpRequest, context: func.Context) -> func.HttpResponse: + return AzureFunctionsWsgi(application).main(req, context) +``` +## Usage +### Install Azure Functions +Follow the instructions [here](https://docs.microsoft.com/azure/azure-functions/functions-create-first-function-python) to get set up locally. +I created a Function called "DjangoTrigger", but you can call yours whatever. +### Install your WSGI app +I found it's easiest if you package your WSGI app using a setup.py script, then `pip install` it. +If you don't want to do that, you'll have to make sure your WSGI entrypoint is importable from the module where you define your Azure Function. +I'm no Python imports expert, so I just added `sys.path.insert(0, './my_proj')` right before I try to import the package. +### Install this package +`pip install azf-wsgi` - no need to put this in Django's `INSTALLED_APPS` or anything like that. +Be sure to update `requirements.txt` to include `azf-wsgi` as a requirement. +### Configure Azure Functions to hand off to your WSGI app +First, we want to delegate routing to your WSGI app. Edit your `function.json` to include a catch-all route called "{*route}": +```json +{ + "scriptFile": "__init__.py", + "bindings": [ + { + "authLevel": "anonymous", + "type": "httpTrigger", + "direction": "in", + "name": "req", + "methods": [ + "get", + "post" + ], + "route": "app/{*route}" + }, + { + "type": "http", + "direction": "out", + "name": "$return" + } + ] +} +``` +I also didn't want the default 'api/' path on all my routes, so I fixed my `host.json` to look like this: +```json +{ + "version": "2.0", + "extensions": { + "http": { + "routePrefix": "" + } + } +} +``` +Without this configuration, the only paths your WSGI app would ever see would start with "api/\<FunctionName\>/". +That works, but it would require you to repeat those boilerplate prefixes on every route you configured. +**However**, you don't want to completely take over all routes (by having an empty `routePrefix` _and_ a catch-all route in your function) because this disables important Azure machinery. +Finally, setup your Function's `__init__.py` to delegate to the WSGI adapter: +```python +import azure.functions as func +from azf_wsgi import AzureFunctionsWsgi +from my_django_app.wsgi import application +def main(req: func.HttpRequest) -> func.HttpResponse: + return AzureFunctionsWsgi(application).main(req) +``` +The adapter optionally takes the `Context` object as well: +```python +def main(req: func.HttpRequest, context: func.Context) -> func.HttpResponse: + return AzureFunctionsWsgi(application).main(req, context) +``` +The adapter will stuff in the OS's environment block much like a CGI request. If for some reason you don't want that, you can pass `False` to `include_os_environ`: +```python +def main(req: func.HttpRequest, context: func.Context) -> func.HttpResponse: + return AzureFunctionsWsgi(application, False).main(req, context) +``` + +%package -n python3-azf-wsgi +Summary: Azure Functions WSGI implementation [deprecated] +Provides: python-azf-wsgi +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-azf-wsgi +This was an adapter package to let you run WSGI apps (Django, Flask, etc.) on Azure Functions. +Example: +```python +import azure.functions as func +# note that the package is "azf-wsgi" but the import is "azf_wsgi" +from azf_wsgi import AzureFunctionsWsgi +# Django, for example, but works with any WSGI app +from my_django_app.wsgi import application +def main(req: func.HttpRequest, context: func.Context) -> func.HttpResponse: + return AzureFunctionsWsgi(application).main(req, context) +``` +## Usage +### Install Azure Functions +Follow the instructions [here](https://docs.microsoft.com/azure/azure-functions/functions-create-first-function-python) to get set up locally. +I created a Function called "DjangoTrigger", but you can call yours whatever. +### Install your WSGI app +I found it's easiest if you package your WSGI app using a setup.py script, then `pip install` it. +If you don't want to do that, you'll have to make sure your WSGI entrypoint is importable from the module where you define your Azure Function. +I'm no Python imports expert, so I just added `sys.path.insert(0, './my_proj')` right before I try to import the package. +### Install this package +`pip install azf-wsgi` - no need to put this in Django's `INSTALLED_APPS` or anything like that. +Be sure to update `requirements.txt` to include `azf-wsgi` as a requirement. +### Configure Azure Functions to hand off to your WSGI app +First, we want to delegate routing to your WSGI app. Edit your `function.json` to include a catch-all route called "{*route}": +```json +{ + "scriptFile": "__init__.py", + "bindings": [ + { + "authLevel": "anonymous", + "type": "httpTrigger", + "direction": "in", + "name": "req", + "methods": [ + "get", + "post" + ], + "route": "app/{*route}" + }, + { + "type": "http", + "direction": "out", + "name": "$return" + } + ] +} +``` +I also didn't want the default 'api/' path on all my routes, so I fixed my `host.json` to look like this: +```json +{ + "version": "2.0", + "extensions": { + "http": { + "routePrefix": "" + } + } +} +``` +Without this configuration, the only paths your WSGI app would ever see would start with "api/\<FunctionName\>/". +That works, but it would require you to repeat those boilerplate prefixes on every route you configured. +**However**, you don't want to completely take over all routes (by having an empty `routePrefix` _and_ a catch-all route in your function) because this disables important Azure machinery. +Finally, setup your Function's `__init__.py` to delegate to the WSGI adapter: +```python +import azure.functions as func +from azf_wsgi import AzureFunctionsWsgi +from my_django_app.wsgi import application +def main(req: func.HttpRequest) -> func.HttpResponse: + return AzureFunctionsWsgi(application).main(req) +``` +The adapter optionally takes the `Context` object as well: +```python +def main(req: func.HttpRequest, context: func.Context) -> func.HttpResponse: + return AzureFunctionsWsgi(application).main(req, context) +``` +The adapter will stuff in the OS's environment block much like a CGI request. If for some reason you don't want that, you can pass `False` to `include_os_environ`: +```python +def main(req: func.HttpRequest, context: func.Context) -> func.HttpResponse: + return AzureFunctionsWsgi(application, False).main(req, context) +``` + +%package help +Summary: Development documents and examples for azf-wsgi +Provides: python3-azf-wsgi-doc +%description help +This was an adapter package to let you run WSGI apps (Django, Flask, etc.) on Azure Functions. +Example: +```python +import azure.functions as func +# note that the package is "azf-wsgi" but the import is "azf_wsgi" +from azf_wsgi import AzureFunctionsWsgi +# Django, for example, but works with any WSGI app +from my_django_app.wsgi import application +def main(req: func.HttpRequest, context: func.Context) -> func.HttpResponse: + return AzureFunctionsWsgi(application).main(req, context) +``` +## Usage +### Install Azure Functions +Follow the instructions [here](https://docs.microsoft.com/azure/azure-functions/functions-create-first-function-python) to get set up locally. +I created a Function called "DjangoTrigger", but you can call yours whatever. +### Install your WSGI app +I found it's easiest if you package your WSGI app using a setup.py script, then `pip install` it. +If you don't want to do that, you'll have to make sure your WSGI entrypoint is importable from the module where you define your Azure Function. +I'm no Python imports expert, so I just added `sys.path.insert(0, './my_proj')` right before I try to import the package. +### Install this package +`pip install azf-wsgi` - no need to put this in Django's `INSTALLED_APPS` or anything like that. +Be sure to update `requirements.txt` to include `azf-wsgi` as a requirement. +### Configure Azure Functions to hand off to your WSGI app +First, we want to delegate routing to your WSGI app. Edit your `function.json` to include a catch-all route called "{*route}": +```json +{ + "scriptFile": "__init__.py", + "bindings": [ + { + "authLevel": "anonymous", + "type": "httpTrigger", + "direction": "in", + "name": "req", + "methods": [ + "get", + "post" + ], + "route": "app/{*route}" + }, + { + "type": "http", + "direction": "out", + "name": "$return" + } + ] +} +``` +I also didn't want the default 'api/' path on all my routes, so I fixed my `host.json` to look like this: +```json +{ + "version": "2.0", + "extensions": { + "http": { + "routePrefix": "" + } + } +} +``` +Without this configuration, the only paths your WSGI app would ever see would start with "api/\<FunctionName\>/". +That works, but it would require you to repeat those boilerplate prefixes on every route you configured. +**However**, you don't want to completely take over all routes (by having an empty `routePrefix` _and_ a catch-all route in your function) because this disables important Azure machinery. +Finally, setup your Function's `__init__.py` to delegate to the WSGI adapter: +```python +import azure.functions as func +from azf_wsgi import AzureFunctionsWsgi +from my_django_app.wsgi import application +def main(req: func.HttpRequest) -> func.HttpResponse: + return AzureFunctionsWsgi(application).main(req) +``` +The adapter optionally takes the `Context` object as well: +```python +def main(req: func.HttpRequest, context: func.Context) -> func.HttpResponse: + return AzureFunctionsWsgi(application).main(req, context) +``` +The adapter will stuff in the OS's environment block much like a CGI request. If for some reason you don't want that, you can pass `False` to `include_os_environ`: +```python +def main(req: func.HttpRequest, context: func.Context) -> func.HttpResponse: + return AzureFunctionsWsgi(application, False).main(req, context) +``` + +%prep +%autosetup -n azf-wsgi-0.3.1 + +%build +%py3_build + +%install +%py3_install +install -d -m755 %{buildroot}/%{_pkgdocdir} +if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi +if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi +if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi +if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi +pushd %{buildroot} +if [ -d usr/lib ]; then + find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/lib64 ]; then + find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/bin ]; then + find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/sbin ]; then + find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst +fi +touch doclist.lst +if [ -d usr/share/man ]; then + find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst +fi +popd +mv %{buildroot}/filelist.lst . +mv %{buildroot}/doclist.lst . + +%files -n python3-azf-wsgi -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Wed May 17 2023 Python_Bot <Python_Bot@openeuler.org> - 0.3.1-1 +- Package Spec generated |