path: root/src/backend/taler-merchant-webhook.c

/*
  This file is part of TALER
  Copyright (C) 2023 Taler Systems SA

  TALER is free software; you can redistribute it and/or modify it under the
  terms of the GNU Affero General Public License as published by the Free Software
  Foundation; either version 3, or (at your option) any later version.

  TALER is distributed in the hope that it will be useful, but WITHOUT ANY
  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more details.

  You should have received a copy of the GNU Affero General Public License along with
  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
*/
/**
 * @file taler-merchant-webhook.c
 * @brief Process that runs webhooks triggered by the merchant backend
 * @author Christian Grothoff
 */
#include "platform.h"
#include <gnunet/gnunet_util_lib.h>
#include <jansson.h>
#include <pthread.h>
#include <curl.h>
#include "taler_merchantdb_lib.h"
#include "taler_merchantdb_plugin.h"
#include "taler_json_lib.h"


struct Work_response
{
  struct Work_response *next;
  struct Work_response *prev;
  struct GNUNET_CURL_Job *job;
  uint64_t webhook_serial;
  char *body;
  struct curl_slist *job_headers;
};


static struct Work_response *w_head;

static struct Work_response *w_tail;

/**
 * The exchange's configuration.
 */
static const struct GNUNET_CONFIGURATION_Handle *cfg;

/**
 * Our database plugin.
 */
static struct TALER_MERCHANTDB_Plugin *db_plugin;

/**
 * Next task to run, if any.
 */
static struct GNUNET_SCHEDULER_Task *task;

/**
 * Handle to the context for interacting with the bank / wire gateway.
 */
static struct GNUNET_CURL_Context *ctx;

/**
 * Scheduler context for running the @e ctx.
 */
static struct GNUNET_CURL_RescheduleContext *rc;

/**
 * Value to return from main(). 0 on success, non-zero on errors.
 */
static int global_ret;

/**
 * #GNUNET_YES if we are in test mode and should exit when idle.
 */
static int test_mode;


/**
 * We're being aborted with CTRL-C (or SIGTERM). Shut down.
 *
 * @param cls closure
 */
static void
shutdown_task (void *cls)
{
  struct Work_response *w;
  
  (void) cls;
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Running shutdown\n");
  if (NULL != task)
  {
    GNUNET_SCHEDULER_cancel (task);
    task = NULL;
  }
  while (NULL != (w = w_head))
  {
    GNUNET_CONTAINER_DLL_remove (w_head,
                                 w_tail,
                                 w);
    GNUNET_CURL_job_cancel (w->job);
    curl_slist_free (w->job_headers);
    GNUNET_free (w->body);
    GNUNET_free (w);
  }
  db_plugin->rollback (db_plugin->cls); /* just in case */
  TALER_MERCHANTDB_plugin_unload (db_plugin);
  db_plugin = NULL;
  cfg = NULL;
  if (NULL != ctx)
  {
    GNUNET_CURL_fini (ctx);
    ctx = NULL;
  }
  if (NULL != rc)
  {
    GNUNET_CURL_gnunet_rc_destroy (rc);
    rc = NULL;
  }
}


/**
 * Select webhook to process.
 *
 * @param cls NULL
 */
static void
select_work (void *cls);

//http request and delete or update in function of the http. And do select work again

/**
 * Function to call upon completion of a raw job.
 *
 * @param cls closure
 * @param response_code HTTP response code from server, 0 on hard error
 * @param body http body of the response
 * @param body_size number of bytes in @a body
 */
static void
handle_webhook_response (void *cls,
                         long response_code,
                         const void *body,
                         size_t body_size)
{
  struct Work_response *w = cls;
  struct GNUNET_TIME_Relative next_attempt;

  (void) body;
  (void) body_size;
  job = NULL;
  // update DB status on the webhook! (delete or update webhook)
  if (2 == response_code / 100) /* any 2xx http status code is OK! */
  {
    db_plugib->delete_pending_webhook (db_plugin->cls,
                                       w->webhook_serial);
  }
  else
  {
    switch (response_code)
      {
      case MHD_HTTP_BAD_REQUEST:
        next_attempt = GNUNET_TIME_UNIT_FOREVER_REL; // never try again
        break;
      case MHD_HTTP_INTERNAL_SERVER_ERROR:
        next_attempt = GNUNET_TIME_UNIT_MINUTES;
        break;
      default:
        next_attempt = GNUNET_TIME_UNIT_HOURS;
        break;
      }
    db_plugin->update_pending_webhook (db_plugin->cls,
                                       w->webhook_serial,
                                       GNUNET_TIME_relative_to_absolute (next_attempt));
  }
  GNUNET_CONTAINER_DLL_remove (w_head,
                               w_tail,
                               w);
  GNUNET_free (w->body);
  curl_slist_free_all (w->job_headers);
  GNUNET_free (w);
  if (NULL == w_head)
    task = GNUNET_SCHEDULER_add_now (&select_work,
                                     NULL);
}


/**
 * Typically called by `lookup_pending_webhooks`.
 *
 * @param cls a `json_t *` JSON array to build
 * @param webhook_serial reference to the configured webhook template.
 * @param next_attempt is the time we should make the next request to the webhook.
 * @param retries how often have we tried this request to the webhook.
 * @param url to make request to
 * @param http_method use for the webhook
 * @param header of the webhook
 * @param body of the webhook
 */
// initialisation curl, and do the job
static void
cb (void *cls,
    uint64_t webhook_serial,
    struct GNUNET_TIME_Absolute next_attempt,
    uint32_t retries,
    const char *url,
    const char *http_method,
    const char *header,
    const char *body)
{
  struct Work_response *w = GNUNET_new (struct Work_response);
  CURL *eh;
  struct curl_slist *job_headers = NULL;

  GNUNET_CONTAINER_DLL_insert (w_head,
                               w_tail,
                               w);
  w->webhook_serial = webhook_serial;
  eh = curl_easy_new ();
  GNUNET_assert (NULL != eh);
  GNUNET_assert (CURLE_OK ==
                 curl_easy_setopt (eh,
                                   CURLOPT_CUSTOMREQUEST,
                                   http_method));
  GNUNET_assert (CURLE_OK ==
                 curl_easy_setopt (eh,
                                   CURLOPT_URL,
                                   url));
  // FIXME: convert header to job_headers!

  w->body = GNUNET_strdup (body);
  GNUNET_assert (CURLE_OK ==
                 curl_easy_setopt (eh,
                                   CURLOPT_POSTFIELDS,
                                   w->body));
  w->job_headers = job_headers;
  w->job = GNUNET_CURL_job_add_raw (ctx,
                                    eh,
                                    job_headers,
                                    &handle_webhook_response,
                                    w);
  if (NULL == w->job)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to start the curl job for webhook #%llu\n",
                (unsigned long long) webhook_serial);
    curl_slist_free_all (w->job_headers);
    GNUNET_free (w->body);
    GNUNET_CONTAINER_DLL_remove (w_head,
                                 w_tail,
                                 w);
    GNUNET_free (w);
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
}


/**
 * Typically called by `lookup_pending_webhooks`.
 *
 * @param cls a `json_t *` JSON array to build
 * @param webhook_serial reference to the configured webhook template.
 * @param next_attempt is the time we should make the next request to the webhook.
 * @param retries how often have we tried this request to the webhook.
 * @param url to make request to
 * @param http_method use for the webhook
 * @param header of the webhook
 * @param body of the webhook
 */
// initialisation curl, and do the job
static void
cb_future (void *cls,
           uint64_t webhook_serial,
           struct GNUNET_TIME_Absolute next_attempt,
           uint32_t retries,
           const char *url,
           const char *http_method,
           const char *header,
           const char *body)
{
  (void) webhook_serial;
  
  task = GNUNET_SCHEDULER_add_at (next_attempt,
                                  &select_work,
                                  NULL);
}


/**
 * Select webhook to process.
 *
 * @param cls NULL
 */
// do the action of the pending webhook
static void
select_work (void *cls)
{
  enum GNUNET_DB_QueryStatus qs;

  (void) cls;
  task = NULL;
  if (GNUNET_SYSERR ==
      db_plugin->preflight (db_plugin->cls))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to obtain database connection!\n");
    global_ret = EXIT_FAILURE;
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  qs = db_plugin->lookup_pending_webhooks (db_plugin->cls,
                                           &cb,
                                           NULL);
  switch (qs)
  {
  // FIXME: handle qs
  case 0:
    qs = db_plugin->lookup_future_webhook (db_plugin->cls,
                                           &cb_future,
                                           NULL);
    switch (qs) {
      // ...
    }
    return;
  case -1 / -2:
    // shutdown.
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed!\n");
    global_ret = EXIT_FAILURE;
    GNUNET_SCHEDULER_shutdown ();
    return;
  default:
    return; // wait for completion, then select more work.
  }
}


/**
 * First task.
 *
 * @param cls closure, NULL
 * @param args remaining command-line arguments
 * @param cfgfile name of the configuration file used (for saving, can be NULL!)
 * @param c configuration
 */
static void
run (void *cls,
     char *const *args,
     const char *cfgfile,
     const struct GNUNET_CONFIGURATION_Handle *c)
{
  (void) cls;
  (void) args;
  (void) cfgfile;

  cfg = c;
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
                                 NULL);
  ctx = GNUNET_CURL_init (&GNUNET_CURL_gnunet_scheduler_reschedule,
                          &rc);
  rc = GNUNET_CURL_gnunet_rc_create (ctx);
  if (NULL == ctx)
  {
    GNUNET_break (0);
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  if (NULL ==
      (db_plugin = TALER_MERCHANTDB_plugin_load (cfg)))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to initialize DB subsystem\n");
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  if (GNUNET_SYSERR ==
      db_plugin->preflight (db_plugin->cls))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to obtain database connection!\n");
    global_ret = EXIT_FAILURE;
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  GNUNET_assert (NULL == task);
  task = GNUNET_SCHEDULER_add_now (&select_work,
                                   NULL);
}


/**
 * The main function of the taler-exchange-transfer.
 *
 * @param argc number of arguments from the command line
 * @param argv command line arguments
 * @return 0 ok, 1 on error
 */
int
main (int argc,
      char *const *argv)
{
  struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_option_flag ('t',
                               "test",
                               "run in test mode and exit when idle",
                               &test_mode),
    GNUNET_GETOPT_option_version (VERSION "-" VCS_VERSION),
    GNUNET_GETOPT_OPTION_END
  };
  enum GNUNET_GenericReturnValue ret;

  if (GNUNET_OK !=
      GNUNET_STRINGS_get_utf8_args (argc, argv,
                                    &argc, &argv))
    return EXIT_INVALIDARGUMENT;
  TALER_OS_init ();
  ret = GNUNET_PROGRAM_run (
    argc, argv,
    "taler-merchant-webhook",
    gettext_noop (
      "background process that executes webhooks"),
    options,
    &run, NULL);
  GNUNET_free_nz ((void *) argv);
  if (GNUNET_SYSERR == ret)
    return EXIT_INVALIDARGUMENT;
  if (GNUNET_NO == ret)
    return EXIT_SUCCESS;
  return global_ret;
}


/* end of taler-exchange-transfer.c */