Merge pull request #557 from remittor-pr/flask

[python] Add Flask framework

Author: MDA2AV

frameworks/flask/Dockerfile

@@ -0,0 +1,7 @@
+FROM python:3.13-slim
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+EXPOSE 8080 8081
+CMD [ "python3", "launcher.py", "gunicorn", "--config", "gunicorn_conf.py", "app:app" ]

frameworks/flask/app.py

@@ -0,0 +1,208 @@
+import os
+import sys
+import multiprocessing
+import json
+import gzip
+import mimetypes
+
+import psycopg_pool
+import psycopg.rows 
+
+from flask import Flask, request, make_response, Response 
+from flask import send_from_directory, jsonify
+
+
+app = Flask(__name__, static_folder = None)
+app.config['JSONIFY_PRETTYPRINT_REGULAR'] = False
+
+
+# -- Dataset and constants --------------------------------------------------------
+
+CPU_COUNT = int(multiprocessing.cpu_count())
+WRK_COUNT = min(len(os.sched_getaffinity(0)), 128)
+WRK_COUNT = max(WRK_COUNT, 4)
+
+DATASET_LARGE_PATH = "/data/dataset-large.json"
+DATASET_PATH = os.environ.get("DATASET_PATH", "/data/dataset.json")
+DATASET_ITEMS = None
+try:
+    with open(DATASET_PATH) as file:
+        DATASET_ITEMS = json.load(file)
+except Exception:
+    pass
+
+
+# -- Postgres DB ------------------------------------------------------------
+
+DATABASE_URL = os.environ.get("DATABASE_URL", '')
+DATABASE_POOL = None
+DATABASE_QUERY = (
+    "SELECT id, name, category, price, quantity, active, tags, rating_score, rating_count"
+    "  FROM items"
+    " WHERE price BETWEEN %s AND %s LIMIT %s"
+)
+if DATABASE_URL and DATABASE_URL.startswith("postgres://"):
+    DATABASE_URL = "postgresql://" + DATABASE_URL[len("postgres://"):]
+
+PG_POOL_MIN_SIZE = 1
+PG_POOL_MAX_SIZE = 2
+
+def db_close():
+    global DATABASE_POOL
+    if DATABASE_POOL:
+        try:
+            DATABASE_POOL.close()
+        except Exception:
+            pass
+    DATABASE_POOL = None
+
+def db_setup():
+    global DATABASE_POOL, DATABASE_URL, PG_POOL_MIN_SIZE, PG_POOL_MAX_SIZE, WRK_COUNT
+    db_close()
+    if not DATABASE_URL:
+        return
+    DATABASE_MAX_CONN = os.environ.get("DATABASE_MAX_CONN", None)
+    if DATABASE_MAX_CONN:
+        avr_pool_size = int(DATABASE_MAX_CONN) * 0.92 / WRK_COUNT
+        #PG_POOL_MIN_SIZE = int(avr_pool_size + 0.35)
+        PG_POOL_MAX_SIZE = int(avr_pool_size + 0.95)
+    try:
+        DATABASE_POOL = psycopg_pool.ConnectionPool(
+            conninfo = DATABASE_URL,
+            min_size = max(PG_POOL_MIN_SIZE, 1),
+            max_size = max(PG_POOL_MAX_SIZE, 2),
+            kwargs = { 'row_factory': psycopg.rows.dict_row },
+        )
+        #DATABASE_POOL.wait()
+    except Exception:
+        DATABASE_POOL = None
+
+db_setup()
+
+        
+# -- flask features ----------------------------------------------------------
+
+@app.after_request
+def compress_response(response):
+    if response.status_code < 200 or response.status_code in (204, 304, 206):
+        return response
+
+    accept_encoding = request.headers.get('Accept-Encoding', '')
+    if 'gzip' not in accept_encoding:
+        return response
+
+    if response.headers.get('Content-Encoding'):
+        return response
+
+    #if response.direct_passthrough:
+    #    return response
+
+    if response.content_length == 0:
+        return response
+
+    try:
+        body = response.get_data()
+    except Exception:
+        return response
+
+    if isinstance(body, str):
+        body = body.encode('utf-8')
+
+    compressed_body = gzip.compress(body, compresslevel = 5)
+    new_response = make_response(compressed_body)
+    new_response.headers.update(response.headers)
+    new_response.headers['Content-Encoding'] = 'gzip'
+    new_response.headers.pop('Content-Length', None)
+    #new_response.headers['Vary'] = new_response.headers.get('Vary', '') + ', Accept-Encoding'
+    return new_response
+
+
+# -- Routes ------------------------------------------------------------------
+
+@app.route('/pipeline')
+def pipeline():
+    return b'ok' 
+
+
+@app.route('/baseline11', methods=['GET', 'POST'])
+def baseline11():
+    total = 0
+    for val in request.args.values():
+        try:
+            total += int(val)
+        except ValueError:
+            pass
+    if request.method == 'POST' and request.data:
+        try:
+            total += int(request.data.strip())
+        except ValueError:
+            pass
+    return str(total)
+
+
+@app.route('/json/<int:count>')
+@app.route('/json-comp/<int:count>')
+def json_endpoint(count: int):
+    global DATASET_ITEMS
+    if not DATASET_ITEMS:
+        return Response("No dataset", status=500)
+    m_val = request.args.get('m', 1, type=float)
+    items = [ ]
+    for idx, dsitem in enumerate(DATASET_ITEMS):
+        if idx >= count:
+            break
+        item = dict(dsitem)
+        item["total"] = dsitem["price"] * dsitem["quantity"] * m_val
+        items.append(item)
+    return { 'items': items, 'count': len(items) }
+
+
+@app.route('/async-db')
+def async_db_endpoint():
+    global DATABASE_POOL
+    if not DATABASE_POOL:
+        return { "items": [ ], "count": 0 }
+    try:
+        min_val = request.args.get('min', type=float)
+        max_val = request.args.get('max', type=float)
+        limit = request.args.get('limit', type=int)
+        with DATABASE_POOL.connection() as db_conn:
+            rows = db_conn.execute(DATABASE_QUERY, (min_val, max_val, limit)).fetchall()
+        items = [
+            {
+                'id'      : row['id'],
+                'name'    : row['name'],
+                'category': row['category'],
+                'price'   : row['price'],
+                'quantity': row['quantity'],
+                'active'  : row['active'],
+                'tags'    : json.loads(row['tags']) if isinstance(row['tags'], str) else row['tags'],
+                'rating': {
+                    'score': row['rating_score'],
+                    'count': row['rating_count'],
+                }
+            }
+            for row in rows
+        ]
+        return { "items": items, "count": len(items) }
+    except Exception:
+        return { "items": [ ], "count": 0 }
+
+
+@app.route('/upload', methods=['POST'])
+def upload_endpoint():
+    size = 0
+    while True:
+        chunk = request.stream.read(256*1024)
+        if not chunk:
+            break
+        size += len(chunk)
+    return str(size)
+
+
+mimetypes.add_type('.woff2', 'font/woff2')
+mimetypes.add_type('.webp', 'image/webp')
+
+@app.route('/static/<path:filepath>')
+def static_endpoint(filepath):
+    return send_from_directory('/data/static', filepath)

frameworks/flask/gunicorn_conf.py

@@ -0,0 +1,22 @@
+import os
+import sys
+import multiprocessing
+import gunicorn
+
+
+_CPU_COUNT = int(multiprocessing.cpu_count())
+_WRK_COUNT = min(len(os.sched_getaffinity(0)), 128)
+_WRK_COUNT = max(_WRK_COUNT, 4)
+
+
+bind = "0.0.0.0:8080"
+workers = _WRK_COUNT
+keepalive = 120
+loglevel = 'critical'
+accesslog = "-"
+errorlog = "-"
+pidfile = "gunicorn.pid"
+worker_class = "sync"
+
+gunicorn.SERVER_SOFTWARE = "Flask"
+os.environ["SERVER_SOFTWARE"] = "Flask"

frameworks/flask/gunicorn_conf_ssl.py

@@ -0,0 +1,27 @@
+import os
+import sys
+import multiprocessing
+import gunicorn
+
+
+_CPU_COUNT = int(multiprocessing.cpu_count())
+_WRK_COUNT = min(len(os.sched_getaffinity(0)), 128)
+_WRK_COUNT = max(_WRK_COUNT, 4)
+
+
+bind = "0.0.0.0:8081"
+workers = _WRK_COUNT
+keepalive = 120
+loglevel = 'critical'
+accesslog = "-"
+errorlog = "-"
+pidfile = "gunicorn_ssl.pid"
+worker_class = "sync"
+
+gunicorn.SERVER_SOFTWARE = "Flask"
+os.environ["SERVER_SOFTWARE"] = "Flask"
+
+default_proc_name = 'gunicorn_ssl'
+
+certfile = os.environ.get("TLS_CERT", "/certs/server.crt")
+keyfile  = os.environ.get("TLS_KEY" , "/certs/server.key")

frameworks/flask/launcher.py

@@ -0,0 +1,58 @@
+import os
+import sys
+import multiprocessing
+import subprocess
+import signal
+import time
+
+
+CPU_COUNT = int(multiprocessing.cpu_count())
+WRK_COUNT = min(len(os.sched_getaffinity(0)), 128)
+WRK_COUNT = max(WRK_COUNT, 4)
+
+
+if len(sys.argv) < 2:
+    print("Usage: launcher.py <program> [args...]", file=sys.stderr)
+    sys.exit(1)
+
+args = sys.argv[1:]     # [ "gunicorn", "--config", "gunicorn_conf.py", "app:app" ]
+
+def run_prog(args: list, ssl: bool = False):
+    config_idx = 0
+    try:
+        config_idx = args.index("--config") + 1
+        base_config = args[config_idx]
+    except Exception:
+        config_idx = 0
+        base_config = ''
+    cmd = list(args)
+    if ssl and (config_idx == 0 or not base_config):
+        return None
+    if ssl:
+        cmd[config_idx] = 'gunicorn_conf_ssl.py'
+    return subprocess.Popen(cmd)
+
+
+http_proc = run_prog(args)
+
+https_proc = run_prog(args, ssl = True)
+
+def shutdown(sig, frame):
+    http_proc.terminate()
+    https_proc.terminate() if https_proc else None
+    time.sleep(1)
+    if http_proc.poll() is None:
+        http_proc.kill()
+    if https_proc and https_proc.poll() is None:
+        https_proc.kill()
+    sys.exit(0)
+
+signal.signal(signal.SIGTERM, shutdown)
+signal.signal(signal.SIGINT, shutdown)
+
+try:
+    http_proc.wait()
+    https_proc.terminate() if https_proc else None
+except Exception:
+    pass
+

frameworks/flask/meta.json

@@ -0,0 +1,23 @@
+{
+  "display_name": "flask",
+  "language": "Python",
+  "type": "production",
+  "engine": "gunicorn",
+  "description": "Flask web framework on Gunicorn with sync workers",
+  "repo": "https://github.com/pallets/flask",
+  "enabled": true,
+  "tests": [
+    "baseline",
+    "pipelined",
+    "limited-conn",
+    "json",
+    "json-comp",
+    "json-tls",
+    "upload",
+    "api-4",
+    "api-16",
+    "async-db",
+    "static"
+  ],
+  "maintainers": []
+}

frameworks/flask/requirements.txt

@@ -0,0 +1,4 @@
+Flask==3.1.3
+gunicorn==25.3.0
+psycopg[binary]==3.3.3
+psycopg_pool==3.3.0