path: root/python-azf-wsgi.spec

%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