cfbot_api.py

import cfbot_github
import cfbot_config
import cfbot_util
import logging
import secrets

from flask import Flask
from flask import request
from flask import jsonify

# extremely primitive approach to connection re-use; need to learn more flask
# philosophy and do better!
conn = cfbot_util.db()


def error_cleanup():
    try:
        conn.rollback()
    except:
        pass
    try:
        conn.close()
    except:
        pass
    conn = cfbot_util.db()


app = Flask("cfbot_api")


# This URL is registered with Github to receive workflow_job events,
# from both postgresql-cfbot/postgres (for cf/* branches) and
# postgres/postgres (for master, REL_* branches).
@app.route("/api/github-webhook", methods=["POST"])
def github_webhook():
    try:
        # This UUID can be found under the Github WebHook settings
        # "Recent Deliveries" tab, with all the details and our
        # response.
        event_uuid = request.headers.get("X-Github-Delivery")
        event_type = request.headers.get("X-Github-Event")
        logging.info("Github webhook: delivery = %s, type = %s", event_uuid, event_type)
        try:
            event = request.json
        except ValueError:
            logging.info("could not decode JSON: %s", request.get_data(as_text=True))
            raise
        if event_type == "workflow_job":
            cfbot_github.handle_workflow_job_webhook(conn, event)
            conn.commit()
            return "OK"
        elif event_type == "workflow_run":
            cfbot_github.handle_workflow_run_webhook(conn, event)
            conn.commit()
            return "OK"
        elif event_type == "push":
            cfbot_github.handle_push_webhook(conn, event)
            conn.commit()
            return "OK"
        else:
            return "unhandled event type " + event_type
    except:
        error_cleanup()
        logging.exception("Error processing webhook")
        return "NOT OK"


@app.route("/api/requeue-patch", methods=["POST"])
def rerun_patch():
    """API endpoint to requeue a specific patch for processing.

    This resets the last_branch_message_id so that the periodic job
    will pick it up and process it on the next run.

    Expected JSON payload:
    {
        "commitfest_id": 123,
        "submission_id": 456,
        "shared_secret": "secret_token"
    }
    """
    if not request.json:
        return jsonify({"error": "Invalid request, JSON payload required"}), 400

    # Extract parameters
    commitfest_id = request.json.get("commitfest_id")
    submission_id = request.json.get("submission_id")
    shared_secret = request.json.get("shared_secret")

    # Validate required parameters
    if not commitfest_id or not submission_id:
        return jsonify({"error": "commitfest_id and submission_id are required"}), 400

    # Check authentication if shared secret is configured
    if (
        hasattr(cfbot_config, "COMMITFEST_SHARED_SECRET")
        and cfbot_config.COMMITFEST_SHARED_SECRET
    ):
        if not shared_secret or not secrets.compare_digest(
            shared_secret, cfbot_config.COMMITFEST_SHARED_SECRET
        ):
            logging.warning(
                "Invalid shared secret for rerun request: cf=%s, sub=%s",
                commitfest_id,
                submission_id,
            )
            return jsonify({"error": "Invalid authentication"}), 403

    # Check if submission exists and get current state
    cursor = conn.cursor()
    cursor.execute(
        """SELECT name, last_message_id
           FROM submission
           WHERE commitfest_id = %s AND submission_id = %s""",
        (commitfest_id, submission_id),
    )
    row = cursor.fetchone()

    if not row:
        return jsonify({"error": "Submission not found"}), 404

    name, last_message_id = row

    # Check if there's actually a message to process
    if not last_message_id:
        return jsonify(
            {
                "error": "No patches found for this submission",
                "commitfest_id": commitfest_id,
                "submission_id": submission_id,
            }
        ), 400

    logging.info(
        "API request to requeue patch: cf=%s, sub=%s, name=%s",
        commitfest_id,
        submission_id,
        name,
    )

    # Reset last_branch_message_id to trigger reprocessing
    # This makes the submission appear as if it has a new patch that hasn't been built yet
    cursor.execute(
        """UPDATE submission
           SET last_branch_message_id = NULL,
               backoff_until = NULL
           WHERE commitfest_id = %s AND submission_id = %s""",
        (commitfest_id, submission_id),
    )
    conn.commit()

    return jsonify({"status": "success"})


# Easy way to run this locally for development.
if __name__ == "__main__":
    app.run(debug=True)