mysql_lease_mgr.h

Go to the documentation of this file.

// Copyright (C) 2012-2022 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#ifndef MYSQL_LEASE_MGR_H
#define MYSQL_LEASE_MGR_H

#include <asiolink/io_service.h>
#include <dhcp/hwaddr.h>
#include <dhcpsrv/dhcpsrv_exceptions.h>
#include <dhcpsrv/lease_mgr.h>
#include <mysql/mysql_connection.h>

#include <boost/scoped_ptr.hpp>
#include <boost/utility.hpp>
#include <mysql.h>

#include <time.h>
#include <vector>
#include <mutex>

namespace isc {
namespace dhcp {

// Forward declaration of the Lease exchange objects.  These classes are defined
// in the .cc file.
class MySqlLease4Exchange;
class MySqlLease6Exchange;

class MySqlLeaseContext {
public:

    MySqlLeaseContext(const db::DatabaseConnection::ParameterMap& parameters,
                      db::IOServiceAccessorPtr io_service_accessor,
                      db::DbCallback db_reconnect_callback);

    boost::scoped_ptr<MySqlLease4Exchange> exchange4_; 
    boost::scoped_ptr<MySqlLease6Exchange> exchange6_; 

    db::MySqlConnection conn_;
};

typedef boost::shared_ptr<MySqlLeaseContext> MySqlLeaseContextPtr;

class MySqlLeaseContextPool {
public:

    std::vector<MySqlLeaseContextPtr> pool_;

    std::mutex mutex_;
};

typedef boost::shared_ptr<MySqlLeaseContextPool> MySqlLeaseContextPoolPtr;


class MySqlLeaseMgr : public LeaseMgr {
public:

    MySqlLeaseMgr(const db::DatabaseConnection::ParameterMap& parameters);

    virtual ~MySqlLeaseMgr();

    MySqlLeaseContextPtr createContext() const;

    static bool dbReconnect(util::ReconnectCtlPtr db_reconnect_ctl);

    static std::string getDBVersion();

    virtual bool addLease(const Lease4Ptr& lease);

    virtual bool addLease(const Lease6Ptr& lease);

    virtual Lease4Ptr getLease4(const isc::asiolink::IOAddress& addr) const;

    virtual Lease4Collection getLease4(const isc::dhcp::HWAddr& hwaddr) const;

    virtual Lease4Ptr getLease4(const isc::dhcp::HWAddr& hwaddr,
                                SubnetID subnet_id) const;

    virtual Lease4Collection getLease4(const ClientId& clientid) const;

    virtual Lease4Ptr getLease4(const ClientId& clientid,
                                SubnetID subnet_id) const;

    virtual Lease4Collection getLeases4(SubnetID subnet_id) const;

    virtual Lease4Collection getLeases4(const std::string& hostname) const;

    virtual Lease4Collection getLeases4() const;

    virtual Lease4Collection
    getLeases4(const asiolink::IOAddress& lower_bound_address,
               const LeasePageSize& page_size) const;

    virtual Lease6Ptr getLease6(Lease::Type type,
                                const isc::asiolink::IOAddress& addr) const;

    virtual Lease6Collection getLeases6(Lease::Type type, const DUID& duid,
                                        uint32_t iaid) const;

    virtual Lease6Collection getLeases6(Lease::Type type, const DUID& duid,
                                        uint32_t iaid, SubnetID subnet_id) const;

    virtual Lease6Collection getLeases6(SubnetID subnet_id) const;

    virtual Lease6Collection getLeases6(const std::string& hostname) const;

    virtual Lease6Collection getLeases6() const;

    virtual Lease6Collection getLeases6(const DUID& duid) const;

    virtual Lease6Collection
    getLeases6(const asiolink::IOAddress& lower_bound_address,
               const LeasePageSize& page_size) const;

    virtual void getExpiredLeases4(Lease4Collection& expired_leases,
                                   const size_t max_leases) const;

    virtual void getExpiredLeases6(Lease6Collection& expired_leases,
                                   const size_t max_leases) const;

    virtual void updateLease4(const Lease4Ptr& lease4);

    virtual void updateLease6(const Lease6Ptr& lease6);

    virtual bool deleteLease(const Lease4Ptr& lease);

    virtual bool deleteLease(const Lease6Ptr& lease);

    virtual uint64_t deleteExpiredReclaimedLeases4(const uint32_t secs);

    virtual uint64_t deleteExpiredReclaimedLeases6(const uint32_t secs);

    virtual LeaseStatsQueryPtr startLeaseStatsQuery4();

    virtual LeaseStatsQueryPtr startSubnetLeaseStatsQuery4(const SubnetID& subnet_id);

    virtual LeaseStatsQueryPtr startSubnetRangeLeaseStatsQuery4(const SubnetID& first_subnet_id,
                                                                const SubnetID& last_subnet_id);

    virtual LeaseStatsQueryPtr startLeaseStatsQuery6();

    virtual LeaseStatsQueryPtr startSubnetLeaseStatsQuery6(const SubnetID& subnet_id);

    virtual LeaseStatsQueryPtr startSubnetRangeLeaseStatsQuery6(const SubnetID& first_subnet_id,
                                                                const SubnetID& last_subnet_id);

    virtual size_t wipeLeases4(const SubnetID& subnet_id);

    virtual size_t wipeLeases6(const SubnetID& subnet_id);

    bool isJsonSupported() const override;

    virtual std::string getType() const {
        return (std::string("mysql"));
    }

    virtual std::string getName() const;

    virtual std::string getDescription() const;

    virtual std::pair<uint32_t, uint32_t> getVersion() const;

    virtual void commit();

    virtual void rollback();

    enum StatementIndex {
        DELETE_LEASE4,               // Delete from lease4 by address
        DELETE_LEASE4_STATE_EXPIRED, // Delete expired lease4 in a given state
        DELETE_LEASE6,               // Delete from lease6 by address
        DELETE_LEASE6_STATE_EXPIRED, // Delete expired lease6 in a given state
        GET_LEASE4,                  // Get all IPv4 leases
        GET_LEASE4_ADDR,             // Get lease4 by address
        GET_LEASE4_CLIENTID,         // Get lease4 by client ID
        GET_LEASE4_CLIENTID_SUBID,   // Get lease4 by client ID & subnet ID
        GET_LEASE4_HWADDR,           // Get lease4 by HW address
        GET_LEASE4_HWADDR_SUBID,     // Get lease4 by HW address & subnet ID
        GET_LEASE4_PAGE,             // Get page of leases beginning with an address
        GET_LEASE4_SUBID,            // Get IPv4 leases by subnet ID
        GET_LEASE4_HOSTNAME,         // Get IPv4 leases by hostname
        GET_LEASE4_EXPIRE,           // Get lease4 by expiration.
        GET_LEASE6,                  // Get all IPv6 leases
        GET_LEASE6_ADDR,             // Get lease6 by address
        GET_LEASE6_DUID_IAID,        // Get lease6 by DUID and IAID
        GET_LEASE6_DUID_IAID_SUBID,  // Get lease6 by DUID, IAID and subnet ID
        GET_LEASE6_PAGE,             // Get page of leases beginning with an address
        GET_LEASE6_SUBID,            // Get IPv6 leases by subnet ID
        GET_LEASE6_DUID,             // Get IPv6 leases by DUID
        GET_LEASE6_HOSTNAME,         // Get IPv6 leases by hostname
        GET_LEASE6_EXPIRE,           // Get lease6 by expiration.
        INSERT_LEASE4,               // Add entry to lease4 table
        INSERT_LEASE6,               // Add entry to lease6 table
        UPDATE_LEASE4,               // Update a Lease4 entry
        UPDATE_LEASE6,               // Update a Lease6 entry
        ALL_LEASE4_STATS,            // Fetches IPv4 lease statistics
        SUBNET_LEASE4_STATS,         // Fetched IPv4 lease stats for a single subnet.
        SUBNET_RANGE_LEASE4_STATS,   // Fetched IPv4 lease stats for a subnet range.
        ALL_LEASE6_STATS,            // Fetches IPv6 lease statistics
        SUBNET_LEASE6_STATS,         // Fetched IPv6 lease stats for a single subnet.
        SUBNET_RANGE_LEASE6_STATS,   // Fetched IPv6 lease stats for a subnet range.
        CHECK_LEASE4_LIMITS,         // Check if allocated IPv4 leases are inside the set limits.
        CHECK_LEASE6_LIMITS,         // Check if allocated IPv6 leases are inside the set limits.
        IS_JSON_SUPPORTED,           // Checks if JSON support is enabled in the database.
        NUM_STATEMENTS               // Number of statements
    };

private:

    bool addLeaseCommon(MySqlLeaseContextPtr& ctx,
                        StatementIndex stindex, std::vector<MYSQL_BIND>& bind);

    template <typename Exchange, typename LeaseCollection>
    void getLeaseCollection(MySqlLeaseContextPtr& ctx,
                            StatementIndex stindex,
                            MYSQL_BIND* bind,
                            Exchange& exchange, LeaseCollection& result,
                            bool single = false) const;

    void getLeaseCollection(MySqlLeaseContextPtr& ctx,
                            StatementIndex stindex,
                            MYSQL_BIND* bind,
                            Lease4Collection& result) const {
        getLeaseCollection(ctx, stindex, bind, ctx->exchange4_, result);
    }

    void getLeaseCollection(MySqlLeaseContextPtr& ctx,
                            StatementIndex stindex,
                            MYSQL_BIND* bind,
                            Lease6Collection& result) const {
        getLeaseCollection(ctx, stindex, bind, ctx->exchange6_, result);
    }

    void getLease(MySqlLeaseContextPtr& ctx,
                  StatementIndex stindex,
                  MYSQL_BIND* bind,
                  Lease4Ptr& result) const;

    void getLease(MySqlLeaseContextPtr& ctx,
                  StatementIndex stindex,
                  MYSQL_BIND* bind,
                  Lease6Ptr& result) const;

    template<typename LeaseCollection>
    void getExpiredLeasesCommon(LeaseCollection& expired_leases,
                                const size_t max_leases,
                                StatementIndex statement_index) const;

    template <typename LeasePtr>
    void updateLeaseCommon(MySqlLeaseContextPtr& ctx,
                           StatementIndex stindex,
                           MYSQL_BIND* bind,
                           const LeasePtr& lease);

    uint64_t deleteLeaseCommon(StatementIndex stindex,
                               MYSQL_BIND* bind);

    uint64_t deleteExpiredReclaimedLeasesCommon(const uint32_t secs,
                                                StatementIndex statement_index);

    std::string
    checkLimits(isc::data::ConstElementPtr const& user_context, StatementIndex const stindex) const;

    std::string checkLimits4(isc::data::ConstElementPtr const& user_context) const override;

    std::string checkLimits6(isc::data::ConstElementPtr const& user_context) const override;

    void checkError(MySqlLeaseContextPtr& ctx,
                    int status, StatementIndex index,
                    const char* what) const;

    class MySqlLeaseContextAlloc {
    public:

        MySqlLeaseContextAlloc(const MySqlLeaseMgr& mgr);

        ~MySqlLeaseContextAlloc();

        MySqlLeaseContextPtr ctx_;

    private:

        const MySqlLeaseMgr& mgr_;
    };

private:

    // Members

    db::DatabaseConnection::ParameterMap parameters_;

    MySqlLeaseContextPoolPtr pool_;

    std::string timer_name_;
};

}  // namespace dhcp
}  // namespace isc

#endif // MYSQL_LEASE_MGR_H