/*
	 * Copyright 2012-2026 the Pacemaker project contributors
	 *
	 * The version control history for this file may have further details.
	 *
	 * This source code is licensed under the GNU Lesser General Public License
	 * version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
	 */
	
	#include <crm_internal.h>
	
	#include <glib.h>
	#include <stdbool.h>
	#include <unistd.h>
	
	#include <crm/crm.h>
	#include <crm/services.h>
	#include <crm/common/mainloop.h>
	
	#include <crm/pengine/status.h>
	#include <crm/pengine/internal.h>
	#include <crm/cib.h>
	#include <crm/cib/internal.h>
	#include <crm/lrmd.h>
	
	#define SUMMARY "cts-exec-helper - inject commands into the Pacemaker executor and watch for events"
	
	static int exec_call_id = 0;
	static gboolean start_test(gpointer user_data);
	static void try_connect(void);
	
	static char *key = NULL;
	static char *val = NULL;
	
	static struct {
	    int verbose;
	    int quiet;
	    guint interval_ms;
	    int timeout;
	    int start_delay;
	    int cancel_call_id;
	    gboolean no_wait;
	    gboolean is_running;
	    gboolean no_connect;
	    int exec_call_opts;
	    const char *api_call;
	    const char *rsc_id;
	    const char *provider;
	    const char *class;
	    const char *type;
	    const char *action;
	    const char *listen;
	    gboolean use_tls;
	    lrmd_key_value_t *params;
	} options;
	
	static gboolean
	interval_cb(const gchar *option_name, const gchar *optarg, gpointer data, GError **error) {
	    return pcmk_parse_interval_spec(optarg,
	                                    &options.interval_ms) == pcmk_rc_ok;
	}
	
	static gboolean
	notify_cb(const gchar *option_name, const gchar *optarg, gpointer data, GError **error) {
	    if (pcmk__str_any_of(option_name, "--notify-orig", "-n", NULL)) {
	        options.exec_call_opts = lrmd_opt_notify_orig_only;
	    } else if (pcmk__str_any_of(option_name, "--notify-changes", "-o", NULL)) {
	        options.exec_call_opts = lrmd_opt_notify_changes_only;
	    }
	
	    return TRUE;
	}
	
	static gboolean
	param_key_val_cb(const gchar *option_name, const gchar *optarg, gpointer data, GError **error) {

	    if (pcmk__str_any_of(option_name, "--param-key", "-k", NULL)) {
	        pcmk__str_update(&key, optarg);

	    } else if (pcmk__str_any_of(option_name, "--param-val", "-v", NULL)) {
	        pcmk__str_update(&val, optarg);
	    }
	

	    if (key != NULL && val != NULL) {
	        options.params = lrmd_key_value_add(options.params, key, val);

	        g_clear_pointer(&key, free);

	        g_clear_pointer(&val, free);
	    }
	
	    return TRUE;
	}
	
	static GOptionEntry basic_entries[] = {
	    { "api-call", 'c', 0, G_OPTION_ARG_STRING, &options.api_call,
	      "Directly relates to executor API functions",
	      NULL },
	
	    { "is-running", 'R', 0, G_OPTION_ARG_NONE, &options.is_running,
	      "Determine if a resource is registered and running",
	      NULL },
	
	    { "listen", 'l', 0, G_OPTION_ARG_STRING, &options.listen,
	      "Listen for a specific event string",
	      NULL },
	
	    { "no-wait", 'w', 0, G_OPTION_ARG_NONE, &options.no_wait,
	      "Make api call and do not wait for result",
	      NULL },
	
	    { "notify-changes", 'o', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, notify_cb,
	      "Only notify client changes to recurring operations",
	      NULL },
	
	    { "notify-orig", 'n', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, notify_cb,
	      "Only notify this client of the results of an API action",
	      NULL },
	
	    { "tls", 'S', 0, G_OPTION_ARG_NONE, &options.use_tls,
	      "Use TLS backend for local connection",
	      NULL },
	
	    { NULL }
	};
	
	static GOptionEntry api_call_entries[] = {
	    { "action", 'a', 0, G_OPTION_ARG_STRING, &options.action,
	      NULL, NULL },
	
	    { "cancel-call-id", 'x', 0, G_OPTION_ARG_INT, &options.cancel_call_id,
	      NULL, NULL },
	
	    { "class", 'C', 0, G_OPTION_ARG_STRING, &options.class,
	      NULL, NULL },
	
	    { "interval", 'i', 0, G_OPTION_ARG_CALLBACK, interval_cb,
	      NULL, NULL },
	
	    { "param-key", 'k', 0, G_OPTION_ARG_CALLBACK, param_key_val_cb,
	      NULL, NULL },
	
	    { "param-val", 'v', 0, G_OPTION_ARG_CALLBACK, param_key_val_cb,
	      NULL, NULL },
	
	    { "provider", 'P', 0, G_OPTION_ARG_STRING, &options.provider,
	      NULL, NULL },
	
	    { "rsc-id", 'r', 0, G_OPTION_ARG_STRING, &options.rsc_id,
	      NULL, NULL },
	
	    { "start-delay", 's', 0, G_OPTION_ARG_INT, &options.start_delay,
	      NULL, NULL },
	
	    { "timeout", 't', 0, G_OPTION_ARG_INT, &options.timeout,
	      NULL, NULL },
	
	    { "type", 'T', 0, G_OPTION_ARG_STRING, &options.type,
	      NULL, NULL },
	
	    { NULL }
	};
	
	static GMainLoop *mainloop = NULL;
	static lrmd_t *lrmd_conn = NULL;
	
	static crm_exit_t
	test_exit(crm_exit_t exit_code)
	{
	    lrmd_api_delete(lrmd_conn);
	    return crm_exit(exit_code);
	}
	
	#define print_result(fmt, args...)  \
	    if (!options.quiet) {           \
	        printf(fmt "\n", ##args);   \
	    }
	
	static void
	test_shutdown(int nsig)
	{
	    g_clear_pointer(&lrmd_conn, lrmd_api_delete);
	}
	
	static void
	read_events(lrmd_event_data_t * event)
	{
	    char buf[1024] = { '\0', };
	
	    pcmk__assert(snprintf(buf, sizeof(buf),
	                          "NEW_EVENT event_type:%s rsc_id:%s action:%s rc:%s "
	                          "op_status:%s",
	                          lrmd_event_type2str(event->type), event->rsc_id,
	                          pcmk__s(event->op_type, "none"),
	                          crm_exit_str((crm_exit_t) event->rc),
	                          pcmk_exec_status_str(event->op_status)) >= 0);
	    pcmk__info("%s", buf);
	
	    if (options.listen && pcmk__str_eq(options.listen, buf, pcmk__str_casei)) {
	        print_result("LISTEN EVENT SUCCESSFUL");
	        test_exit(CRM_EX_OK);
	    }
	
	    if (exec_call_id && (event->call_id == exec_call_id)) {
	        if (event->op_status == 0 && event->rc == 0) {
	            print_result("API-CALL SUCCESSFUL for 'exec'");
	        } else {
	            print_result("API-CALL FAILURE for 'exec', rc:%d lrmd_op_status:%s",
	                         event->rc, pcmk_exec_status_str(event->op_status));
	            test_exit(CRM_EX_ERROR);
	        }
	
	        if (!options.listen) {
	            test_exit(CRM_EX_OK);
	        }
	    }
	}
	
	static gboolean
	timeout_err(gpointer data)
	{
	    print_result("LISTEN EVENT FAILURE - timeout occurred, never found");
	    test_exit(CRM_EX_TIMEOUT);
	    return FALSE;
	}
	
	static void
	connection_events(lrmd_event_data_t * event)
	{
	    int rc = event->connection_rc;
	
	    if (event->type != lrmd_event_connect) {
	        /* ignore */
	        return;
	    }
	
	    if (!rc) {
	        pcmk__info("Executor client connection established");
	        start_test(NULL);
	        return;
	    } else {
	        sleep(1);
	        try_connect();
	        pcmk__notice("Executor client connection failed");
	    }
	}
	
	static void
	try_connect(void)
	{
	    int tries = 10;
	    static int num_tries = 0;
	    int rc = 0;
	
	    lrmd_conn->cmds->set_callback(lrmd_conn, connection_events);
	    for (; num_tries < tries; num_tries++) {
	        rc = lrmd_conn->cmds->connect_async(lrmd_conn, crm_system_name, 3000);
	
	        if (!rc) {
	            return;             /* we'll hear back in async callback */
	        }
	        sleep(1);
	    }
	
	    print_result("API CONNECTION FAILURE");
	    test_exit(CRM_EX_ERROR);
	}
	
	static gboolean
	start_test(gpointer user_data)
	{
	    int rc = 0;
	
	    if (!options.no_connect) {
	        if (!lrmd_conn->cmds->is_connected(lrmd_conn)) {
	            try_connect();
	            /* async connect -- this function will get called back into */
	            return 0;
	        }
	    }
	    lrmd_conn->cmds->set_callback(lrmd_conn, read_events);
	
	    if (options.timeout) {
	        pcmk__create_timer(options.timeout, timeout_err, NULL);
	    }
	
	    if (!options.api_call) {
	        return 0;
	    }
	
	    if (pcmk__str_eq(options.api_call, "exec", pcmk__str_casei)) {
	        rc = lrmd_conn->cmds->exec(lrmd_conn,
	                                   options.rsc_id,
	                                   options.action,
	                                   NULL,
	                                   options.interval_ms,
	                                   options.timeout,
	                                   options.start_delay,
	                                   options.exec_call_opts,
	                                   options.params);
	
	        if (rc > 0) {
	            exec_call_id = rc;
	            print_result("API-CALL 'exec' action pending, waiting on response");
	        }
	
	    } else if (pcmk__str_eq(options.api_call, "register_rsc", pcmk__str_casei)) {
	        rc = lrmd_conn->cmds->register_rsc(lrmd_conn,
	                                           options.rsc_id,
	                                           options.class, options.provider, options.type, 0);
	    } else if (pcmk__str_eq(options.api_call, "get_rsc_info", pcmk__str_casei)) {
	        lrmd_rsc_info_t *rsc_info;
	
	        rsc_info = lrmd_conn->cmds->get_rsc_info(lrmd_conn, options.rsc_id, 0);
	
	        if (rsc_info) {
	            print_result("RSC_INFO: id:%s class:%s provider:%s type:%s",
	                         rsc_info->id, rsc_info->standard,
	                         (rsc_info->provider? rsc_info->provider : "<none>"),
	                         rsc_info->type);
	            lrmd_free_rsc_info(rsc_info);
	            rc = pcmk_ok;
	        } else {
	            rc = -1;
	        }
	    } else if (pcmk__str_eq(options.api_call, "unregister_rsc", pcmk__str_casei)) {
	        rc = lrmd_conn->cmds->unregister_rsc(lrmd_conn, options.rsc_id, 0);
	    } else if (pcmk__str_eq(options.api_call, "cancel", pcmk__str_casei)) {
	        rc = lrmd_conn->cmds->cancel(lrmd_conn, options.rsc_id, options.action,
	                                     options.interval_ms);
	    } else if (pcmk__str_eq(options.api_call, "metadata", pcmk__str_casei)) {
	        char *output = NULL;
	
	        rc = lrmd_conn->cmds->get_metadata(lrmd_conn,
	                                           options.class,
	                                           options.provider, options.type, &output, 0);
	        if (rc == pcmk_ok) {
	            print_result("%s", output);
	            free(output);
	        }
	    } else if (pcmk__str_eq(options.api_call, "list_agents", pcmk__str_casei)) {
	        lrmd_list_t *list = NULL;
	        lrmd_list_t *iter = NULL;
	
	        rc = lrmd_conn->cmds->list_agents(lrmd_conn, &list, options.class, options.provider);
	
	        if (rc > 0) {
	            print_result("%d agents found", rc);
	            for (iter = list; iter != NULL; iter = iter->next) {
	                print_result("%s", iter->val);
	            }
	            lrmd_list_freeall(list);
	            rc = 0;
	        } else {
	            print_result("API_CALL FAILURE - no agents found");
	            rc = -1;
	        }
	    } else if (pcmk__str_eq(options.api_call, "list_ocf_providers", pcmk__str_casei)) {
	        lrmd_list_t *list = NULL;
	        lrmd_list_t *iter = NULL;
	
	        rc = lrmd_conn->cmds->list_ocf_providers(lrmd_conn, options.type, &list);
	
	        if (rc > 0) {
	            print_result("%d providers found", rc);
	            for (iter = list; iter != NULL; iter = iter->next) {
	                print_result("%s", iter->val);
	            }
	            lrmd_list_freeall(list);
	            rc = 0;
	        } else {
	            print_result("API_CALL FAILURE - no providers found");
	            rc = -1;
	        }
	
	    } else if (pcmk__str_eq(options.api_call, "list_standards", pcmk__str_casei)) {
	        lrmd_list_t *list = NULL;
	        lrmd_list_t *iter = NULL;
	
	        rc = lrmd_conn->cmds->list_standards(lrmd_conn, &list);
	
	        if (rc > 0) {
	            print_result("%d standards found", rc);
	            for (iter = list; iter != NULL; iter = iter->next) {
	                print_result("%s", iter->val);
	            }
	            lrmd_list_freeall(list);
	            rc = 0;
	        } else {
	            print_result("API_CALL FAILURE - no providers found");
	            rc = -1;
	        }
	
	    } else if (pcmk__str_eq(options.api_call, "get_recurring_ops", pcmk__str_casei)) {
	        GList *op_list = NULL;
	        GList *op_item = NULL;
	        rc = lrmd_conn->cmds->get_recurring_ops(lrmd_conn, options.rsc_id, 0, 0,
	                                                &op_list);
	
	        for (op_item = op_list; op_item != NULL; op_item = op_item->next) {
	            lrmd_op_info_t *op_info = op_item->data;
	
	            print_result("RECURRING_OP: %s_%s_%s timeout=%sms",
	                         op_info->rsc_id, op_info->action,
	                         op_info->interval_ms_s, op_info->timeout_ms_s);
	            lrmd_free_op_info(op_info);
	        }
	        g_list_free(op_list);
	
	    } else if (options.api_call) {
	        print_result("API-CALL FAILURE unknown action '%s'", options.action);
	        test_exit(CRM_EX_ERROR);
	    }
	
	    if (rc < 0) {
	        print_result("API-CALL FAILURE for '%s' api_rc:%d",
	                     options.api_call, rc);
	        test_exit(CRM_EX_ERROR);
	    }
	
	    if (options.api_call && rc == pcmk_ok) {
	        print_result("API-CALL SUCCESSFUL for '%s'", options.api_call);
	        if (!options.listen) {
	            test_exit(CRM_EX_OK);
	        }
	    }
	
	    if (options.no_wait) {
	        /* just make the call and exit regardless of anything else. */
	        test_exit(CRM_EX_OK);
	    }
	
	    return 0;
	}
	
	/*!
	 * \internal
	 * \brief Generate resource parameters from CIB if none explicitly given
	 *
	 * \return Standard Pacemaker return code
	 */
	static int
	generate_params(void)
	{
	    int rc = pcmk_rc_ok;
	    pcmk_scheduler_t *scheduler = NULL;
	    xmlNode *cib_xml_copy = NULL;
	    pcmk_resource_t *rsc = NULL;
	    GHashTable *params = NULL;
	    GHashTableIter iter;
	    char *key = NULL;
	    char *value = NULL;
	
	    if (options.params != NULL) {
	        return pcmk_rc_ok; // User specified parameters explicitly
	    }
	
	    // Retrieve and update CIB
	    rc = cib__signon_query(NULL, NULL, &cib_xml_copy);
	    if (rc != pcmk_rc_ok) {
	        return rc;
	    }
	    rc = pcmk__update_configured_schema(&cib_xml_copy, false);
	    if (rc != pcmk_rc_ok) {
	        return rc;
	    }
	
	    // Calculate cluster status
	    scheduler = pcmk_new_scheduler();
	    if (scheduler == NULL) {
	        pcmk__crit("Could not allocate scheduler data");
	        return ENOMEM;
	    }
	    pcmk__set_scheduler_flags(scheduler, pcmk__sched_no_counts);
	    scheduler->input = cib_xml_copy;
	    scheduler->priv->now = crm_time_new(NULL);
	    cluster_status(scheduler);
	
	    // Find resource in CIB
	    rsc = pe_find_resource_with_flags(scheduler->priv->resources,
	                                      options.rsc_id,
	                                      pcmk_rsc_match_history
	                                      |pcmk_rsc_match_basename);
	    if (rsc == NULL) {
	        pcmk__err("Resource does not exist in config");
	        pcmk_free_scheduler(scheduler);
	        return EINVAL;
	    }
	
	    // Add resource instance parameters to options.params
	    params = pe_rsc_params(rsc, NULL, scheduler);
	    if (params != NULL) {
	        g_hash_table_iter_init(&iter, params);
	        while (g_hash_table_iter_next(&iter, (gpointer *) &key,
	                                      (gpointer *) &value)) {
	            options.params = lrmd_key_value_add(options.params, key, value);
	        }
	    }
	
	    // Add resource meta-attributes to options.params
	    g_hash_table_iter_init(&iter, rsc->priv->meta);
	    while (g_hash_table_iter_next(&iter, (gpointer *) &key,
	                                  (gpointer *) &value)) {
	        char *crm_name = crm_meta_name(key);
	
	        options.params = lrmd_key_value_add(options.params, crm_name, value);
	        free(crm_name);
	    }
	
	    pcmk_free_scheduler(scheduler);
	    return rc;
	}
	
	static GOptionContext *
	build_arg_context(pcmk__common_args_t *args, GOptionGroup **group) {
	    GOptionContext *context = NULL;
	
	    context = pcmk__build_arg_context(args, NULL, group, NULL);
	
	    pcmk__add_main_args(context, basic_entries);
	    pcmk__add_arg_group(context, "api-call", "API Call Options:",
	                        "Parameters for api-call option", api_call_entries);
	
	    return context;
	}
	
	int
	main(int argc, char **argv)
	{
	    GError *error = NULL;
	    crm_exit_t exit_code = CRM_EX_OK;
	    crm_trigger_t *trig = NULL;
	
	    pcmk__common_args_t *args = pcmk__new_common_args(SUMMARY);
	    /* Typically we'd pass all the single character options that take an argument
	     * as the second parameter here (and there's a bunch of those in this tool).
	     * However, we control how this program is called so we can just not call it
	     * in a way where the preprocessing ever matters.
	     */
	    gchar **processed_args = pcmk__cmdline_preproc(argv, NULL);
	    GOptionContext *context = build_arg_context(args, NULL);
	
	    if (!g_option_context_parse_strv(context, &processed_args, &error)) {
	        exit_code = CRM_EX_USAGE;
	        goto done;
	    }
	
	    /* We have to use crm_log_init here to set up the logging because there's
	     * different handling for daemons vs. command line programs, and
	     * pcmk__cli_init_logging is set up to only handle the latter.
	     */
	    crm_log_init(NULL, LOG_INFO, TRUE, (args->verbosity? TRUE : FALSE), argc,
	                 argv, FALSE);
	
	    for (int i = 0; i < args->verbosity; i++) {
	        crm_bump_log_level(argc, argv);
	    }
	
	    if (!options.listen && pcmk__strcase_any_of(options.api_call, "metadata", "list_agents",
	                                                "list_standards", "list_ocf_providers", NULL)) {
	        options.no_connect = TRUE;
	    }
	
	    if (options.is_running) {
	        int rc = pcmk_rc_ok;
	
	        if (options.rsc_id == NULL) {
	            exit_code = CRM_EX_USAGE;
	            g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	                        "--is-running requires --rsc-id");
	            goto done;
	        }
	
	        options.interval_ms = 0;
	        if (options.timeout == 0) {
	            options.timeout = 30000;
	        }
	
	        rc = generate_params();
	        if (rc != pcmk_rc_ok) {
	            exit_code = pcmk_rc2exitc(rc);
	            g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	                        "Can not determine resource status: "
	                        "unable to get parameters from CIB");
	            goto done;
	        }
	        options.api_call = "exec";
	        options.action = PCMK_ACTION_MONITOR;
	        options.exec_call_opts = lrmd_opt_notify_orig_only;
	    }
	
	    if (!options.api_call && !options.listen) {
	        exit_code = CRM_EX_USAGE;
	        g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
	                    "Must specify at least one of --api-call, --listen, "
	                    "or --is-running");
	        goto done;
	    }
	
	    if (options.use_tls) {
	        lrmd_conn = lrmd_remote_api_new(NULL, "localhost", 0);
	    } else {
	        lrmd_conn = lrmd_api_new();
	    }
	    trig = mainloop_add_trigger(G_PRIORITY_HIGH, start_test, NULL);
	    mainloop_set_trigger(trig);
	    mainloop_add_signal(SIGTERM, test_shutdown);
	
	    pcmk__info("Starting");
	    mainloop = g_main_loop_new(NULL, FALSE);
	    g_main_loop_run(mainloop);
	
	done:
	    g_strfreev(processed_args);
	    pcmk__free_arg_context(context);
	
	    free(key);
	    free(val);
	
	    pcmk__output_and_clear_error(&error, NULL);
	    return test_exit(exit_code);
	}