update to us os.getenv, runs server when imported

import os

import sys

import psycopg2

import requests

import redis

from flask import Blueprint

from flask import Flask, jsonify, request

from celery import Celery

from common.env import check_environment as ce

from common.logz import create_logger

logger = create_logger()

blueprint = Blueprint('api', __name__)

def create_flask_server():

    app = Flask(__name__)

    @app.route('/healthcheck', methods=['GET'])

    def health_check():

        return jsonify(status="OK"), 200

    @blueprint.route('/postgres_healthcheck', methods=['GET'])

    def postgres_healthcheck():

        env_vars = ["DATABASE_DB_PG", "DATABASE_DB", "PG_DATABASE"]

        dbname = [var for var in env_vars if os.getenv(var) is not None]

        if not dbname:

            return "Need to set either DATABASE_DB_PG or DATABASE_DB ENV variables", 503

        elif len(dbname) > 1:

            logger.warn("Found multiple PostgreSQL ENV vars, using first one: " + str(dbname[0]))

        elif dbname[0] == 'postgres':

            logger.warn("Using default database name: " + dbname[0])

        else:

            logger.info("Database name set to: " + str(dbname[0]))

        env_vars = ["DATABASE_USER", "DATABASE_USER_PG", "PG_USER"]

        user = [var for var in env_vars if os.getenv(var) is not None]

        if not user:

            return "Need to set either DATABASE_USER_PG or DATABASE_USER ENV variables", 503

        elif len(user) > 1:

            logger.warn("Found multiple PostgreSQL ENV vars, using first one: " + str(user[0]))

        elif user[0] == 'postgres':

            logger.warn("Using default user: " + user[0])

        else:

            logger.info("Database User set to: " + str(user))

        env_vars = ["DATABASE_PW", "DATABASE_PW_PG", "PG_PASSWORD"]

        password = [var for var in env_vars if os.getenv(var) is not None]

        if not password:

            return "Need to set either DATABASE_PW_PG or DATABASE_PW ENV variables", 503

        elif password[0] == 'postgres':

            logger.warn("Using default password: " + password)

        else:

            logger.info("Database Password set to: " + str(password))

        env_vars = ["DATABASE_HOST", "DATABASE_HOST_PG", "PG_HOST"]

        host = [var for var in env_vars if os.getenv(var) is not None]

        if not host:

            return "Need to set either DATABASE_HOST_PG or DATABASE_HOST ENV variables", 503

        elif host[0] == 'localhost':

            logger.warn("Using default host: " + host)

        else:

            logger.info("Database host set to: " + str(host))

        env_vars = ["DATABASE_PORT", "DATABASE_PORT_PW", "PG_PORT"]

        port = [var for var in env_vars if os.getenv(var) is not None]

        if not port:

            return "Need to set either DATABASE_PORT_PG or DATABASE_PORT ENV variables", 503

        elif port[0] == 5432:

            logger.warn("Using default port: " + str(port))

        else:

            logger.info("Database port set to: " + str(port))

        try:

            conn = psycopg2.connect(

                dbname=dbname,

                user=user,

                password=password,

                host=host, port=port

            )

            cursor = conn.cursor()

            cursor.execute("SELECT version();")

            db_version = cursor.fetchone()

            cursor.close()

            conn.close()

            if db_version:

                return "Database is running", 200

            else:

                return "Database does not seem to be running", 503

        except psycopg2.Error as e:

            logger.critical("Error connecting to PostgreSQL:" + str(e))

            return "Error connecting to PostgreSQL:" + str(e), 503

    @blueprint.route('/mssql_healthcheck', methods=['GET'])

    def mssql_healthcheck():

        env_vars = ["DATABASE_DB_MS", "DATABASE_DB"]

        dbname = [var for var in env_vars if os.getenv(var) is not None]

        if not dbname:

            return "Need to set either DATABASE_DB_MS or DATABASE_DB ENV variables", 503

        elif dbname[0] == 'CommonDB':

            logger.warn("Using default database name: " + dbname)

        else:

            logger.info("Database name set to: " + str(dbname))

        env_vars = ["DATABASE_USER_MS", "DATABASE_USER"]

        user = [var for var in env_vars if os.getenv(var) is not None]

        if not user:

            return "Need to set either DATABASE_USER_MS or DATABASE_USER ENV variables", 503

        elif user[0] == 'sa':

            logger.warn("Using default user: " + user)

        else:

            logger.info("Database User set to: " + str(user))

        env_vars = ["DATABASE_PW_MS", "DATABASE_PW"]

        password = [var for var in env_vars if os.getenv(var) is not None]

        if not password:

            return "Need to set either DATABASE_PW_MS or DATABASE_PW ENV variables", 503

        elif password[0] == '5nowDog5':

            logger.warn("Using default password: " + password)

        else:

            logger.info("Database Password set to: " + str(password))

        env_vars = ["DATABASE_HOST_MS", "DATABASE_HOST"]

        host = [var for var in env_vars if os.getenv(var) is not None]

        if not host:

            return "Need to set either DATABASE_HOST_MS or DATABASE_HOST ENV variables", 503

        elif host[0] == 'localhost':

            logger.warn("Using default host: " + host)

        else:

            logger.info("Database host set to: " + str(host))

        env_vars = ["DATABASE_PORT_MS", "DATABASE_PORT_MS"]

        port = [var for var in env_vars if os.getenv(var) is not None]

        if not port:

            return "Need to set either DATABASE_PORT_MS or DATABASE_PORT ENV variables", 503

        elif port[0] == 1433:

            logger.warn("Using default port: " + str(port))

        else:

            logger.info("Database port set to: " + str(port))

        try:

            conn = psycopg2.connect(

                dbname=dbname,

                user=user,

                password=password,

                host=host,

                port=port

            )

            cursor = conn.cursor()

            cursor.execute("SELECT version();")

            db_version = cursor.fetchone()

            cursor.close()

            conn.close()

            if db_version:

                return "Database is running", 200

            else:

                return "Database does not seem to be running", 503

        except psycopg2.Error as e:

            logger.critical("Error connecting to PostgreSQL:" + str(e))

            return "Error connecting to PostgreSQL:" + str(e), 503

    @blueprint.route('/rabbitmq_healthcheck', methods=['GET'])

    def rabbitmq_healthcheck():

        host = "RABBIT_MQ_HOST"

        if not os.getenv(host):

            return "Need to set RABBIT_MQ_HOST variable", 503

        elif host == 'localhost':

            logger.warn("Using default host: " + host)

        else:

            logger.info("RabbitMQ host set to: " + str(host))

        port = "RABBIT_MQ_PORT"

        if not os.getenv(port):

            return "Need to set RABBIT_MQ_PORT ENV variable", 503

        elif port == 15692:

            logger.warn("Using default port: " + str(port))

        else:

            logger.info("RabbitMQ port set to: " + str(port))

        r = requests.get(host)

        if r.status_code == 200:

            return "Healthcheck good", 200

        else:

            return "Healthcheck failed", r.status_code

    @blueprint.route('/redis_healthcheck', methods=['GET'])

    def redis_healthcheck():

        host = "REDIS_HOST"

        if not os.getenv(host):

            return "Need to set REDIS_HOST ENV variable", 503

        elif host == 'localhost':

            logger.warn("Using default host: " + host)

        else:

            logger.info("RabbitMQ host set to: " + str(host))

        port = "REDIS_PORT"

        if not os.getenv(port):

            return "Need to set REDIS_PORT ENV variable", 503

        elif port == 6379:

            logger.warn("Using default port: " + str(port))

        else:

            logger.info("RabbitMQ port set to: " + str(port))

        try:

            r = redis.Redis(host=host, port=port, decode_responses=True)

            r.hset('test', mapping={'get': 'healthcheck'})

            res = r.hgetall('test')

            if res == {}:

                return "Queried Redis, but data was empty", 200

            elif 'test' in res:

                return "Healthcheck good", 200

            else:

                return "Redis may be running, but there was an unknown issue", 200

        except Exception:

            return "There was an error, check your redis cluster", 500

    def make_celery():

        if not os.getenv('REDIS_BROKER'):

            logger.critical("No REDIS_BROKER ENV variable found, please set it!")

        else:

            broker = os.getenv('REDIS_BROKER')

        return Celery(broker=broker)  # Replace with your broker URL

    @app.route('/celery_healthcheck')

    def celery_healthcheck():

        try:

            celery = make_celery()  # Create a new Celery instance just for this check

            inspector = celery.control.inspect()

            active_workers = inspector.ping()

            if not active_workers:

                return jsonify({"status": "failure", "message": "No active workers found"}), 503

            return jsonify({"status": "success", "message": "All workers are operational"}), 200

        except Exception as e:

            return jsonify({"status": "failure", "message": str(e)}), 500

    # @app.route('/static/swagger.json')

    # def swagger_spec():

    #     print(request.status_code)

    return app

    app.register_blueprint(blueprint)

    return app

# if __name__ == '__main__':

app = create_flask_server()

app.run(host='0.0.0.0', port=5000)

# TODO

# celery health check

# swaggerui