Upgrade from 2.6.0 to 3.0.1, and all APIs are unavailable

[czchen]

Hi,

We try to upgrade connextion from 2.6.0 to 3.0.1, and all endpoints are unavailable. It looks like add_api does not work at all. Since there is no error, we have no idea how to solve the problem. Any through?

The following is code to setup app:

def get_bundled_specs(file):
    parser = prance.ResolvingParser(str(file.absolute()),
                                    lazy=True,
                                    backend='openapi-spec-validator')
    parser.parse()
    return parser.specification


def get_flask_app():
    connexion_app = connexion.FlaskApp(
        __name__,
        specification_dir='openapi/',
        swagger_ui_options=SwaggerUIOptions(**config['app']['connexion_options']),
    )

    connexion_app.add_api(
        get_bundled_specs(pathlib.Path(__file__).parent / 'openapi' / 'api.yml'),
        strict_validation=True,
        validate_responses=True,
    )

    flask_app = connexion_app.app
    # skip some code
    return flask_app

[RobbeSneyders]

Hi @czchen,
You should make sure to run the Connexion app instead of the underlying Flask app.

-   return flask_app
+   return connexion_app

[czchen]

I got the following error when running ``flask --app 'app:get_flask_app()' run --debug`. It looks like I need to use another way to launch the application?

Error: A valid Flask application was not obtained from 'app:get_flask_app()'.

[RobbeSneyders]

Yes, you should use an ASGI server.

Note that the built-in flask server is just meant for development, and a dedicated server is recommended when running in production anyway (flask docs).

Check our docs for:

• How to run your connexion application
• An overview of the changes in Connexion 3

[czchen]

I manage to run the application with gunicorn -k uvicorn.workers.UvicornWorker 'app:get_app()', thanks for the information.

However, in testing, connexion_app.app.test_client does not work. The Flask test_client always return 404. Any idea how to fix this?

[czchen]

Looks like we shall use connexion_app.test_client() instead of connexion.app.test_client().

[RobbeSneyders]

Yes indeed. Note that this this test client implements the interface of httpx instead of requests.

[czchen]

We found that when using connexion_app.test_client(), it has 500 internal error without any log. This 500 happens in a complex app, but not a simpler one. Any idea how to debug this situation?

[RobbeSneyders]

Also, note that you should no longer need Prance. Connexion 3 can resolve references in the specification for you.

[czchen]

That's great. Thanks for the information.

[shariqueakbare]

I tried multiple way to make connexion 3.0.0 works, but at the end i revert to my old code. Please have a look and let me knows what should be changed to keep connexion and Flask :

i'm using python manage.py run to launch my API for testing purpose ( poetry run python manage.py run)

from app.app_file import app

def routes():
    """Show all routes available"""
    print(app.url_map)


def run():
    """Run the application"""
    routes()
    app.run(host="0.0.0.0", port=8006, debug=True)  # nosec


if __name__ == "__main__":
    run()

here the code of my flask app
app/app_file.py

from flask import g, request

from app import create_app

# Create app
connexion_app = create_app()
app = connexion_app.app
========>>>

app/init .py

import connexion
import urllib3
from flask_caching import Cache
from flask_cors import CORS

from app.configs import BaseConfig
from app.error_handlers import ErrorHandlers

urllib3.disable_warnings()


cache = Cache()

def create_app(config=BaseConfig):
    """
    To setup Flask app.
    """
    options = {
        "swagger_url": "documentation",
    }

    # Create the Connexion application instance
    connexion_app = connexion.FlaskApp(__name__, specification_dir="./openapi/", options=options)
    connexion_app.app.url_map.strict_slashes = False
    connexion_app.add_api(
        "api.yml",
    )

    # Get the underlying Flask app instance
    app = connexion_app.app

    # Load configuration into the app
    app.config.from_object(BaseConfig)

    # Enable Cross Origin Resource Sharing
    CORS(app)

    # Enable caching
    cache.init_app(app, app.config)

    # Add exception error handlers
    register_error_handler(connexion_app)

    return connexion_app


def register_error_handler(app):
    error_handlers = ErrorHandlers()
    error_handlers.init_app(app)

error_handlers.py

import logging

import requests
from flask import jsonify
from werkzeug.exceptions import BadGateway, BadRequest, Forbidden, InternalServerError, NotFound, Unauthorized

logger = logging.getLogger(__name__)


class ErrorHandlers:
    """
    High level error handling class.
    """

    @staticmethod
    def handle_authentication_error_exception(exception):
        """
        authentication_error_exception handler.

        :param exception: the exception object to handle
        :return: a tuple with a user friendly message and a status code
        """
        if hasattr(exception, "description"):
            message = exception.description
        else:
            message = str(exception)
        status_code = 401
        logger.exception(str(exception))
        response = {
            "error": {
                "message": message,
                "type": "Unauthorized",
                "code": status_code,
                "details": "",
            }
        }
        return jsonify(response), status_code

  ===>>>>

   multiple block catching

    def init_app(self, connexion_app):
        connexion_app.add_error_handler(Unauthorized, self.handle_authentication_error_exception)
        connexion_app.add_error_handler(
            requests.exceptions.ConnectionError,
            self.handle_connection_error_exception,
        )
        ===>>>>>
        )

[RobbeSneyders]

There's a couple of things you'll need to change, but the main one is the one already mentioned in this discussion:
Run your connexion app instead of the underlying Flask app

For development:

- connexion_app.app.run()
+ connexion_app.run()

For production:

- wsgi-server connexion_app.app
+ asgi-server connexion_app

Error handlers

Ideally you update your error handlers to match the new interface and register them on the Connexion application. If you want to have a quick fix, you can keep your old error handlers and register them on the underlying Flask app.

Error handler documentation

CORS

You should leverage the CORSMiddleware instead of flask_cors

CORS documentation

Swagger UI options

Pass in a SwaggerUIOptions class instead of a dict

Swagger UI documentation

---

We spent a great amount of effort to update and improve our documentation for Connexion 3. Please try to use it to find your answers there.

If you run into specific errors, you can open an issue explaining the error and we can support on that error specifically. If we notice any gaps in our documentation based on these issues, we update it.

[shariqueakbare]

great i will try it ! what about flask-caching ? it is still supported ?

[juhoinkinen]

I have tried to upgrade to Connexion 3 in this PR, the application factory is here.

When trying to start Flask(App) server with

flask --app annif:create_app run

I'm getting the same message as @czchen #1795 (reply in thread):

Error: A valid Flask application was not obtained from 'annif:create_app'.

When printing out the type of the return object of create_app (in my case cxapp) it is shown to be

<class 'connexion.apps.flask.FlaskApp'>

The application starts fine when using gunicorn with uvicorn workers:

gunicorn "annif:create_app()" --worker-class uvicorn.workers.UvicornWorker

I wonder what goes wrong when using FlaskApp? For development continuing to use Flask as in Connexion v2.* would be really good (and maybe also necessary to be able to use Click and Connexion in the same application?).

---

Edit: @RobbeSneyders when you are saying

Yes, you should use an ASGI server.

Note that the built-in flask server is just meant for development, and a dedicated server is recommended when running in production anyway (flask docs).

do you mean that ASGI server needs to be always used to run the application (actually that is how I understand the docs in here)? And the built-in FlaskApp is just for creating the application (docs in here)? Is there a difference in running and creating the app?