/*
 * Copyright (c) 2018 MariaDB Corporation Ab
 *
 * Use of this software is governed by the Business Source License included
 * in the LICENSE.TXT file and at www.mariadb.com/bsl11.
 *
 * Change Date: 2022-01-01
 *
 * On the date above, in accordance with the Business Source License, use
 * of this software will be governed by version 2 or later of the General
 * Public License.
 */
#pragma once

/**
 * @file include/maxscale/monitor.hh - The public monitor interface
 */

#include <maxscale/ccdefs.hh>

#include <atomic>
#include <openssl/sha.h>
#include <maxbase/semaphore.hh>
#include <maxbase/worker.hh>
#include <maxbase/jansson.h>
#include <maxscale/config.hh>
#include <maxscale/dcb.h>
#include <maxscale/server.hh>
#include <maxscale/protocol/mysql.h>

MXS_BEGIN_DECLS

struct mxs_monitor;
typedef struct mxs_monitor MXS_MONITOR;

/**
 * An opaque type from which types specific for a particular
 * monitor can be derived.
 */
typedef struct mxs_monitor_instance
{
} MXS_MONITOR_INSTANCE;

/**
 * @verbatim
 * The "module object" structure for a backend monitor module
 *
 * Monitor modules monitor the backend databases that MaxScale connects to.
 * The information provided by a monitor is used in routing decisions.
 *
 * The entry points are:
 *      startMonitor    Called by main to start the monitor
 *      stopMonitor     Called by main to shut down and destroy a monitor
 *      diagnostics     Called for diagnostic output
 *
 * startMonitor is called to start the monitoring process, it is called on the
 * MaxScale main thread and is responsible for creating a thread for the monitor
 * itself to run on. This should use the entry points defined in the thread.h
 * header file rather than make direct calls to the operating system threading
 * libraries. The return from startMonitor is a pointer that will be passed to
 * all other monitor API calls.
 *
 * @endverbatim
 *
 * @see load_module
 */
typedef struct mxs_monitor_api
{
    /**
     * @brief Create the monitor.
     *
     * This entry point is called once when MaxScale is started, for
     * creating the monitor.
     *
     * If the function fails, MaxScale will not start. That is, it
     * should fail only for fatal reasons such as not being able to
     * create vital resources.
     *
     * @param monitor  The monitor object.
     *
     * @return Pointer to the monitor specific data. Will be stored
     *         in @c monitor->handle.
     */
    MXS_MONITOR_INSTANCE*(*createInstance)(MXS_MONITOR * monitor);

    /**
     * @brief Destroy the monitor.
     *
     * This entry point is called once when MaxScale is shutting down, iff
     * the earlier call to @c initMonitor returned on object. The monitor should
     * perform all needed cleanup.
     *
     * @param monitor  The monitor object.
     */
    void (* destroyInstance)(MXS_MONITOR_INSTANCE* monitor);

    /**
     * @brief Start the monitor
     *
     * This entry point is called when the monitor is started. If the monitor
     * requires polling of the servers, it should create a separate monitoring
     * thread.
     *
     * @param monitor The monitor object
     * @param params  Parameters for this monitor
     *
     * @return True, if the monitor could be started, false otherwise.
     */
    bool (* startMonitor)(MXS_MONITOR_INSTANCE* monitor,
                          const MXS_CONFIG_PARAMETER* params);

    /**
     * @brief Stop the monitor
     *
     * This entry point is called when the monitor is stopped. If the monitor
     * uses a polling thread, the thread should be stopped.
     *
     * @param monitor The monitor object
     */
    void (* stopMonitor)(MXS_MONITOR_INSTANCE* monitor);

    /**
     * @brief Write diagnostic information to a DCB.
     *
     * @param monitor  The monitor object.
     * @param dcb      The dcb to write to.
     */
    void (* diagnostics)(const MXS_MONITOR_INSTANCE* monitor, DCB* dcb);

    /**
     * @brief Return diagnostic information about the monitor
     *
     * @param monitor  The monitor object.
     *
     * @return A JSON object representing the state of the monitor
     *
     * @see jansson.h
     */
    json_t* (*diagnostics_json)(const MXS_MONITOR_INSTANCE * monitor);
} MXS_MONITOR_API;

/**
 * The monitor API version number. Any change to the monitor module API
 * must change these versions using the rules defined in modinfo.h
 */
#define MXS_MONITOR_VERSION {4, 0, 0}

/**
 * Specifies capabilities specific for monitor.
 *
 * @see enum routing_capability
 *
 * @note The values of the capabilities here *must* be between 0x0001 0000 0000 0000
 *       and 0x0080 0000 0000 0000, that is, bits 48 to 55.
 */
typedef enum monitor_capability
{
    MCAP_TYPE_NONE = 0x0    // TODO: remove once monitor capabilities are defined
} monitor_capability_t;

/** Monitor's poll frequency */
#define MXS_MON_BASE_INTERVAL_MS 100

#define MXS_MONITOR_DEFAULT_ID 1UL      // unsigned long value

#define MAX_MONITOR_USER_LEN     512
#define MAX_MONITOR_PASSWORD_LEN 512

// Monitor state enum
typedef enum
{
    MONITOR_STATE_RUNNING,
    MONITOR_STATE_STOPPING,
    MONITOR_STATE_STOPPED
} monitor_state_t;

/* Return type of mon_ping_or_connect_to_db(). */
typedef enum
{
    MONITOR_CONN_EXISTING_OK,   /* Existing connection was ok and server replied to ping. */
    MONITOR_CONN_NEWCONN_OK,    /* No existing connection or no ping reply. New connection created
                                 * successfully. */
    MONITOR_CONN_REFUSED,       /* No existing connection or no ping reply. Server refused new connection. */
    MONITOR_CONN_TIMEOUT        /* No existing connection or no ping reply. Timeout on new connection. */
} mxs_connect_result_t;

/** Monitor events */
typedef enum
{
    UNDEFINED_EVENT   = 0,
    MASTER_DOWN_EVENT = (1 << 0),   /**< master_down */
    MASTER_UP_EVENT   = (1 << 1),   /**< master_up */
    SLAVE_DOWN_EVENT  = (1 << 2),   /**< slave_down */
    SLAVE_UP_EVENT    = (1 << 3),   /**< slave_up */
    SERVER_DOWN_EVENT = (1 << 4),   /**< server_down */
    SERVER_UP_EVENT   = (1 << 5),   /**< server_up */
    SYNCED_DOWN_EVENT = (1 << 6),   /**< synced_down */
    SYNCED_UP_EVENT   = (1 << 7),   /**< synced_up */
    DONOR_DOWN_EVENT  = (1 << 8),   /**< donor_down */
    DONOR_UP_EVENT    = (1 << 9),   /**< donor_up */
    NDB_DOWN_EVENT    = (1 << 10),  /**< ndb_down */
    NDB_UP_EVENT      = (1 << 11),  /**< ndb_up */
    LOST_MASTER_EVENT = (1 << 12),  /**< lost_master */
    LOST_SLAVE_EVENT  = (1 << 13),  /**< lost_slave */
    LOST_SYNCED_EVENT = (1 << 14),  /**< lost_synced */
    LOST_DONOR_EVENT  = (1 << 15),  /**< lost_donor */
    LOST_NDB_EVENT    = (1 << 16),  /**< lost_ndb */
    NEW_MASTER_EVENT  = (1 << 17),  /**< new_master */
    NEW_SLAVE_EVENT   = (1 << 18),  /**< new_slave */
    NEW_SYNCED_EVENT  = (1 << 19),  /**< new_synced */
    NEW_DONOR_EVENT   = (1 << 20),  /**< new_donor */
    NEW_NDB_EVENT     = (1 << 21),  /**< new_ndb */
} mxs_monitor_event_t;

/**
 * The linked list of servers that are being monitored by the monitor module.
 */
typedef struct monitored_server
{
    SERVER*                  server;/**< The server being monitored */
    MYSQL*                   con;   /**< The MySQL connection */
    bool                     log_version_err;
    int                      mon_err_count;
    uint64_t                 mon_prev_status;   /**< Status before starting the current monitor loop */
    uint64_t                 pending_status;    /**< Status during current monitor loop */
    int64_t                  disk_space_checked;/**< When was the disk space checked the last time */
    struct monitored_server* next;              /**< The next server in the list */
} MXS_MONITORED_SERVER;

/**
 * Representation of the running monitor.
 */
struct mxs_monitor
{
    char*                 name;                                 /**< The name of the monitor module */
    char                  user[MAX_MONITOR_USER_LEN];           /*< Monitor username */
    char                  password[MAX_MONITOR_PASSWORD_LEN];   /*< Monitor password */
    pthread_mutex_t       lock;
    MXS_CONFIG_PARAMETER* parameters;                       /*< configuration parameters */
    MXS_MONITORED_SERVER* monitored_servers;                /*< List of servers the monitor monitors */
    monitor_state_t       state;                            /**< The state of the monitor. This should ONLY be
                                                             * written to by the admin
                                                             *   thread. */
    int connect_timeout;                                    /**< Connect timeout in seconds for
                                                             * mysql_real_connect */
    int connect_attempts;                                   /**< How many times a connection is attempted */
    int read_timeout;                                       /**< Timeout in seconds to read from the server.
                                                             *   There are retries and the total effective
                                                             * timeout
                                                             *   value is three times the option value.
                                                             */
    int write_timeout;                                      /**< Timeout in seconds for each attempt to write
                                                             * to the server.
                                                             * There are retries and the total effective
                                                             * timeout value is
                                                             * two times the option value.
                                                             */
    MXS_MONITOR_API*      api;                              /**< The monitor api */
    char*                 module_name;                      /**< Name of the monitor module */
    MXS_MONITOR_INSTANCE* instance;                         /**< Instance returned from startMonitor */
    size_t                interval;                         /**< The monitor interval */
    int                   check_maintenance_flag;           /**< Set when admin requests a maintenance status
                                                             * change. */
    bool                   active;                          /**< True if monitor is active */
    time_t                 journal_max_age;                 /**< Maximum age of journal file */
    uint32_t               script_timeout;                  /**< Timeout in seconds for the monitor scripts */
    const char*            script;                          /**< Launchable script. */
    uint64_t               events;                          /**< Enabled monitor events. */
    uint8_t                journal_hash[SHA_DIGEST_LENGTH]; /**< SHA1 hash of the latest written journal */
    MxsDiskSpaceThreshold* disk_space_threshold;            /**< Disk space thresholds */
    int64_t                disk_space_check_interval;       /**< How often should a disk space check be made
                                                             * at most. */
    uint64_t            ticks;                              /**< Number of performed monitoring intervals */
    struct mxs_monitor* next;                               /**< Next monitor in the linked list */
};

/**
 * Monitor configuration parameters names
 */
extern const char CN_BACKEND_CONNECT_ATTEMPTS[];
extern const char CN_BACKEND_CONNECT_TIMEOUT[];
extern const char CN_BACKEND_READ_TIMEOUT[];
extern const char CN_BACKEND_WRITE_TIMEOUT[];
extern const char CN_DISK_SPACE_CHECK_INTERVAL[];
extern const char CN_EVENTS[];
extern const char CN_JOURNAL_MAX_AGE[];
extern const char CN_MONITOR_INTERVAL[];
extern const char CN_SCRIPT[];
extern const char CN_SCRIPT_TIMEOUT[];

bool check_monitor_permissions(MXS_MONITOR* monitor, const char* query);

void monitor_clear_pending_status(MXS_MONITORED_SERVER* ptr, uint64_t bit);
void monitor_set_pending_status(MXS_MONITORED_SERVER* ptr, uint64_t bit);
void monitor_check_maintenance_requests(MXS_MONITOR* monitor);

bool mon_status_changed(MXS_MONITORED_SERVER* mon_srv);
bool mon_print_fail_status(MXS_MONITORED_SERVER* mon_srv);

mxs_connect_result_t mon_ping_or_connect_to_db(MXS_MONITOR* mon, MXS_MONITORED_SERVER* database);
bool                 mon_connection_is_ok(mxs_connect_result_t connect_result);
void                 mon_log_connect_error(MXS_MONITORED_SERVER* database, mxs_connect_result_t rval);
const char*          mon_get_event_name(mxs_monitor_event_t event);

/**
 * Alter monitor parameters
 *
 * The monitor parameters should not be altered while the monitor is
 * running. To alter a parameter from outside a monitor module, stop the monitor,
 * do the alteration and then restart the monitor. The monitor "owns" the parameters
 * as long as it is running so if the monitor needs to change its own parameters,
 * it can do it without stopping itself.
 *
 * @param monitor Monitor whose parameter is altered
 * @param key     Parameter name to alter
 * @param value   New value for the parameter
 */
void mon_alter_parameter(MXS_MONITOR* monitor, const char* key, const char* value);

/**
 * @brief Handle state change events
 *
 * This function should be called by all monitors at the end of each monitoring
 * cycle. This will log state changes and execute any scripts that should be executed.
 *
 * @param monitor Monitor object
 * @param script Script to execute or NULL for no script
 * @param events Enabled events
 */
void mon_process_state_changes(MXS_MONITOR* monitor, const char* script, uint64_t events);

/**
 * @brief Hangup connections to failed servers
 *
 * Injects hangup events for DCB that are connected to servers that are down.
 *
 * @param monitor Monitor object
 */
void mon_hangup_failed_servers(MXS_MONITOR* monitor);

/**
 * @brief Report query errors
 *
 * @param db Database where the query failed
 */
void mon_report_query_error(MXS_MONITORED_SERVER* db);

/**
 * @brief Convert monitor to JSON
 *
 * @param monitor Monitor to convert
 * @param host    Hostname of this server
 *
 * @return JSON representation of the monitor
 */
json_t* monitor_to_json(const MXS_MONITOR* monitor, const char* host);

/**
 * @brief Convert all monitors to JSON
 *
 * @param host    Hostname of this server
 *
 * @return JSON array containing all monitors
 */
json_t* monitor_list_to_json(const char* host);

/**
 * @brief Get links to monitors that relate to a server
 *
 * @param server Server to inspect
 * @param host   Hostname of this server
 *
 * @return Array of monitor links or NULL if no relations exist
 */
json_t* monitor_relations_to_server(const SERVER* server, const char* host);

/**
 * @brief Store a journal of server states
 *
 * @param monitor Monitor to journal
 * @param master  The current master server or NULL if no master exists
 */
void store_server_journal(MXS_MONITOR* monitor, MXS_MONITORED_SERVER* master);

/**
 * @brief Load a journal of server states
 *
 * @param monitor Monitor where journal is loaded
 * @param master  Set to point to the current master
 */
void load_server_journal(MXS_MONITOR* monitor, MXS_MONITORED_SERVER** master);

/**
 * Find the monitored server representing the server.
 *
 * @param mon Cluster monitor
 * @param search_server Server to search for
 * @return Found monitored server or NULL if not found
 */
MXS_MONITORED_SERVER* mon_get_monitored_server(const MXS_MONITOR* mon, SERVER* search_server);

/**
 * Get an array of monitored servers. If a server defined in the config setting is not monitored by
 * the given monitor, that server is ignored and not inserted into the output array.
 *
 * @param params Config parameters
 * @param key Setting name
 * @param mon Monitor which should monitor the servers
 * @param monitored_servers_out Where to save output array. The caller should free the array, but not the
 * elements. The output must contain NULL before calling this function.
 * @return Output array size.
 */
int mon_config_get_servers(const MXS_CONFIG_PARAMETER* params,
                           const char* key,
                           const MXS_MONITOR* mon,
                           MXS_MONITORED_SERVER*** monitored_array_out);

/**
 * @brief Set the disk space threshold of a monitor
 *
 * @param server                The monitor.
 * @param disk_space_threshold  The disk space threshold as specified in the config file.
 *
 * @return True, if the provided string is valid and the threshold could be set.
 */
bool monitor_set_disk_space_threshold(MXS_MONITOR* monitor, const char* disk_space_threshold);

// Function for waiting one monitor interval
void monitor_debug_wait();

MXS_END_DECLS

namespace maxscale
{

class MonitorInstance : public MXS_MONITOR_INSTANCE
                      , protected maxbase::Worker
{
public:
    MonitorInstance(const MonitorInstance&) = delete;
    MonitorInstance& operator=(const MonitorInstance&) = delete;

    virtual ~MonitorInstance();

    /**
     * @brief Current state of the monitor.
     *
     * Since the state is written to by the admin thread, the value returned in other threads cannot be fully
     * trusted. The state should only be read in the admin thread or operations launched by the admin thread.
     *
     * @return @c MONITOR_STATE_RUNNING if the monitor is running,
     *         @c MONITOR_STATE_STOPPING if the monitor is stopping, and
     *         @c MONITOR_STATE_STOPPED if the monitor is stopped.
     */
    monitor_state_t monitor_state() const;

    /**
     * @brief Find out whether the monitor is running.
     *
     * @return True, if the monitor is running, false otherwise.
     *
     * @see state().
     */
    bool is_running() const
    {
        return monitor_state() == MONITOR_STATE_RUNNING;
    }

    /**
     * @brief Starts the monitor.
     *
     * - Calls @c has_sufficient_permissions(), if it has not been done earlier.
     * - Updates the 'script' and 'events' configuration paramameters.
     * - Calls @c configure().
     * - Starts the monitor thread.
     *
     * - Once the monitor thread starts, it will
     *   - Load the server journal and update @c m_master.
     *   - Call @c pre_loop().
     *   - Enter a loop where it, until told to shut down, will
     *     - Check whether there are maintenance requests.
     *     - Call @c tick().
     *     - Call @c process_state_changes()
     *     - Hang up failed servers.
     *     - Store the server journal (@c m_master assumed to reflect the current situation).
     *     - Sleep until time for next @c tick().
     *   - Call @c post_loop().
     *
     * @param param  The parameters of the monitor.
     *
     * @return True, if the monitor started, false otherwise.
     */
    bool start(const MXS_CONFIG_PARAMETER* params);

    /**
     * @brief Stops the monitor.
     *
     * When the function returns, the monitor has stopped.
     */
    void stop();

    /**
     * @brief Write diagnostics
     *
     * The implementation should write diagnostic information to the
     * provided dcb. The default implementation writes nothing.
     *
     * @param dcb  The dcb to write to.
     */
    virtual void diagnostics(DCB* dcb) const;

    /**
     * @brief Obtain diagnostics
     *
     * The implementation should create a JSON object and fill it with diagnostics
     * information. The default implementation returns an object that is populated
     * with the keys 'script' and 'events' if they have been set, otherwise the
     * object is empty.
     *
     * @return An object, if there is information to return, NULL otherwise.
     */
    virtual json_t* diagnostics_json() const;

    /**
     * Get current time from the monotonic clock.
     *
     * @return Current time
     */
    static int64_t get_time_ms();

protected:
    MonitorInstance(MXS_MONITOR* pMonitor);

    /**
     * @brief Should the monitor shut down?
     *
     * @return True, if the monitor should shut down, false otherwise.
     */
    bool should_shutdown() const
    {
        return atomic_load_int32(&m_shutdown) != 0;
    }

    /**
     * @brief Should the disk space status be updated.
     *
     * @param pMonitored_server  The monitored server in question.
     *
     * @return True, if the disk space should be checked, false otherwise.
     */
    bool should_update_disk_space_status(const MXS_MONITORED_SERVER* pMonitored_server) const;

    /**
     * @brief Update the disk space status of a server.
     *
     * After the call, the bit @c SERVER_DISK_SPACE_EXHAUSTED will be set on
     * @c pMonitored_server->pending_status if the disk space is exhausted
     * or cleared if it is not.
     */
    void update_disk_space_status(MXS_MONITORED_SERVER* pMonitored_server);

    /**
     * @brief Configure the monitor.
     *
     * When the monitor is started, this function will be called in order
     * to allow the concrete implementation to configure itself from
     * configuration parameters. The default implementation returns true.
     *
     * @return True, if the monitor could be configured, false otherwise.
     *
     * @note If false is returned, then the monitor will not be started.
     */
    virtual bool configure(const MXS_CONFIG_PARAMETER* pParams);

    /**
     * @brief Check whether the monitor has sufficient rights
     *
     * The implementation should check whether the monitor user has sufficient
     * rights to access the servers. The default implementation returns True.
     *
     * @return True, if the monitor user has sufficient rights, false otherwise.
     */
    virtual bool has_sufficient_permissions() const;

    /**
     * @brief Flush pending server status to each server.
     *
     * This function is expected to flush the pending status to each server.
     * The default implementation simply copies monitored_server->pending_status
     * to server->status.
     */
    virtual void flush_server_status();

    /**
     * @brief Monitor the servers
     *
     * This function is called once per monitor round, and the concrete
     * implementation should probe all servers and set server status bits.
     */
    virtual void tick() = 0;

    /**
     * @brief Called before the monitor loop is started
     *
     * The default implementation does nothing.
     */
    virtual void pre_loop();

    /**
     * @brief Called after the monitor loop has ended.
     *
     * The default implementation does nothing.
     */
    virtual void post_loop();

    /**
     * @brief Called after tick returns
     *
     * The default implementation will call @mon_process_state_changes.
     */
    virtual void process_state_changes();

    /**
     * Should a monitor tick be ran immediately? The base class version always returns false. A monitor can
     * override this to add specific conditions. This function is called every MXS_MON_BASE_INTERVAL_MS
     * (100 ms) by the monitor worker thread, which then runs a monitor tick if true is returned.
     *
     * @return True if tick should be ran
     */
    virtual bool immediate_tick_required() const;

    MXS_MONITOR*          m_monitor;    /**< The generic monitor structure. */
    MXS_MONITORED_SERVER* m_master;     /**< Master server */

private:
    std::atomic<bool> m_thread_running; /**< Thread state. Only visible inside MonitorInstance. */
    int32_t           m_shutdown;       /**< Non-zero if the monitor should shut down. */
    bool              m_checked;        /**< Whether server access has been checked. */
    mxb::Semaphore    m_semaphore;      /**< Semaphore for synchronizing with monitor thread. */
    int64_t           m_loop_called;    /**< When was the loop called the last time. */

    bool pre_run() final;
    void post_run() final;

    bool call_run_one_tick(Worker::Call::action_t action);
    void run_one_tick();
};

class MonitorInstanceSimple : public MonitorInstance
{
public:
    MonitorInstanceSimple(const MonitorInstanceSimple&) = delete;
    MonitorInstanceSimple& operator=(const MonitorInstanceSimple&) = delete;

protected:
    MonitorInstanceSimple(MXS_MONITOR* pMonitor)
        : MonitorInstance(pMonitor)
    {
    }

    /**
     * @brief Update server information
     *
     * The implementation should probe the server in question and update
     * the server status bits.
     */
    virtual void update_server_status(MXS_MONITORED_SERVER* pMonitored_server) = 0;

    /**
     * @brief Called right at the beginning of @c tick().
     *
     * The default implementation does nothing.
     */
    virtual void pre_tick();

    /**
     * @brief Called right before the end of @c tick().
     *
     * The default implementation does nothing.
     */
    virtual void post_tick();

private:
    /**
     * @brief Monitor the servers
     *
     * This function is called once per monitor round and will for each server:
     *
     *   - Do nothing, if the server is in maintenance.
     *   - Store the previous status of the server.
     *   - Set the pending status of the monitored server object
     *     to the status of the corresponding server object.
     *   - Ensure that there is a connection to the server.
     *     If there is, @c update_server_status() is called.
     *     If there is not, the pending status will be updated accordingly and
     *     @c update_server_status() will *not* be called.
     *   - After the call, update the error count of the server if it is down.
     */
    void tick();    // final
};

/**
 * The purpose of the template MonitorApi is to provide an implementation
 * of the monitor C-API. The template is instantiated with a class that
 * provides the actual behaviour of a monitor.
 */
template<class MonitorInstance>
class MonitorApi
{
public:
    MonitorApi() = delete;
    MonitorApi(const MonitorApi&) = delete;
    MonitorApi& operator=(const MonitorApi&) = delete;

    static MXS_MONITOR_INSTANCE* createInstance(MXS_MONITOR* pMonitor)
    {
        MonitorInstance* pInstance = NULL;
        MXS_EXCEPTION_GUARD(pInstance = MonitorInstance::create(pMonitor));
        return pInstance;
    }

    static void destroyInstance(MXS_MONITOR_INSTANCE* pInstance)
    {
        MXS_EXCEPTION_GUARD(delete static_cast<MonitorInstance*>(pInstance));
    }

    static bool startMonitor(MXS_MONITOR_INSTANCE* pInstance,
                             const MXS_CONFIG_PARAMETER* pParams)
    {
        bool started = false;
        MXS_EXCEPTION_GUARD(started = static_cast<MonitorInstance*>(pInstance)->start(pParams));
        return started;
    }

    static void stopMonitor(MXS_MONITOR_INSTANCE* pInstance)
    {
        MXS_EXCEPTION_GUARD(static_cast<MonitorInstance*>(pInstance)->stop());
    }

    static void diagnostics(const MXS_MONITOR_INSTANCE* pInstance, DCB* pDcb)
    {
        MXS_EXCEPTION_GUARD(static_cast<const MonitorInstance*>(pInstance)->diagnostics(pDcb));
    }

    static json_t* diagnostics_json(const MXS_MONITOR_INSTANCE* pInstance)
    {
        json_t* pJson = NULL;
        MXS_EXCEPTION_GUARD(pJson = static_cast<const MonitorInstance*>(pInstance)->diagnostics_json());
        return pJson;
    }

    static MXS_MONITOR_API s_api;
};

template<class MonitorInstance>
MXS_MONITOR_API MonitorApi<MonitorInstance>::s_api =
{
    &MonitorApi<MonitorInstance>::createInstance,
    &MonitorApi<MonitorInstance>::destroyInstance,
    &MonitorApi<MonitorInstance>::startMonitor,
    &MonitorApi<MonitorInstance>::stopMonitor,
    &MonitorApi<MonitorInstance>::diagnostics,
    &MonitorApi<MonitorInstance>::diagnostics_json,
};
}