memfile_lease_mgr.h 16.7 KB
Newer Older
1
// Copyright (C) 2012-2013 Internet Systems Consortium, Inc. ("ISC")
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
// AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
// PERFORMANCE OF THIS SOFTWARE.

#ifndef MEMFILE_LEASE_MGR_H
#define MEMFILE_LEASE_MGR_H

18
#include <dhcp/hwaddr.h>
19
#include <dhcpsrv/key_from_key.h>
20 21
#include <dhcpsrv/lease_mgr.h>

22 23
#include <boost/multi_index/indexed_by.hpp>
#include <boost/multi_index/member.hpp>
24 25
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index_container.hpp>
26
#include <boost/multi_index/composite_key.hpp>
27

28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
namespace isc {
namespace dhcp {

// This is a concrete implementation of a Lease database.
//
// It is for testing purposes only. It is NOT a production code.
//
// It does not do anything useful now, and is used for abstract LeaseMgr
// class testing. It may later evolve into more useful backend if the
// need arises. We can reuse code from memfile benchmark. See code in
// tests/tools/dhcp-ubench/memfile_bench.{cc|h}
class Memfile_LeaseMgr : public LeaseMgr {
public:

    /// @brief The sole lease manager constructor
    ///
    /// dbconfig is a generic way of passing parameters. Parameters
    /// are passed in the "name=value" format, separated by spaces.
    /// Values may be enclosed in double quotes, if needed.
    ///
48 49 50
    /// @param parameters A data structure relating keywords and values
    ///        concerned with the database.
    Memfile_LeaseMgr(const ParameterMap& parameters);
51 52 53 54 55 56 57

    /// @brief Destructor (closes file)
    virtual ~Memfile_LeaseMgr();

    /// @brief Adds an IPv4 lease.
    ///
    /// @param lease lease to be added
Tomek Mrugalski's avatar
Tomek Mrugalski committed
58
    virtual bool addLease(const Lease4Ptr& lease);
59 60 61 62

    /// @brief Adds an IPv6 lease.
    ///
    /// @param lease lease to be added
Tomek Mrugalski's avatar
Tomek Mrugalski committed
63
    virtual bool addLease(const Lease6Ptr& lease);
64 65 66

    /// @brief Returns existing IPv4 lease for specified IPv4 address.
    ///
67 68 69 70
    /// This function returns a copy of the lease. The modification in the
    /// return lease does not affect the instance held in the lease storage.
    ///
    /// @param addr An address of the searched lease.
71 72
    ///
    /// @return a collection of leases
73
    virtual Lease4Ptr getLease4(const isc::asiolink::IOAddress& addr) const;
74 75 76 77 78 79 80 81 82 83 84

    /// @brief Returns existing IPv4 leases for specified hardware address.
    ///
    /// Although in the usual case there will be only one lease, for mobile
    /// clients or clients with multiple static/fixed/reserved leases there
    /// can be more than one. Thus return type is a container, not a single
    /// pointer.
    ///
    /// @param hwaddr hardware address of the client
    ///
    /// @return lease collection
85
    virtual Lease4Collection getLease4(const isc::dhcp::HWAddr& hwaddr) const;
86

87
    /// @brief Returns existing IPv4 lease for specified hardware address
88 89
    ///        and a subnet
    ///
90 91
    /// This function returns a copy of the lease. The modification in the
    /// return lease does not affect the instance held in the lease storage.
Tomek Mrugalski's avatar
Tomek Mrugalski committed
92
    ///
93 94 95 96 97 98 99 100 101 102 103 104 105 106 107
    /// There can be at most one lease for a given HW address in a single
    /// pool, so this method with either return a single lease or NULL.
    ///
    /// @param hwaddr hardware address of the client
    /// @param subnet_id identifier of the subnet that lease must belong to
    ///
    /// @return a pointer to the lease (or NULL if a lease is not found)
    virtual Lease4Ptr getLease4(const HWAddr& hwaddr,
                                SubnetID subnet_id) const;

    /// @brief Returns existing IPv4 lease for specified client-id
    ///
    /// @param clientid client identifier
    virtual Lease4Collection getLease4(const ClientId& clientid) const;

108 109 110 111 112 113 114 115 116 117 118 119 120 121 122
    /// @brief Returns IPv4 lease for specified client-id/hwaddr/subnet-id tuple
    ///
    /// There can be at most one lease for a given client-id/hwaddr tuple
    /// in a single pool, so this method with either return a single lease
    /// or NULL.
    ///
    /// @param clientid client identifier
    /// @param hwaddr hardware address of the client
    /// @param subnet_id identifier of the subnet that lease must belong to
    ///
    /// @return a pointer to the lease (or NULL if a lease is not found)
    virtual Lease4Ptr getLease4(const ClientId& clientid,
                                const HWAddr& hwaddr,
                                SubnetID subnet_id) const;

123 124
    /// @brief Returns existing IPv4 lease for specified client-id
    ///
125 126 127
    /// This function returns a copy of the lease. The modification in the
    /// return lease does not affect the instance held in the lease storage.
    ///
128 129 130 131 132 133 134 135 136 137 138 139
    /// There can be at most one lease for a given HW address in a single
    /// pool, so this method with either return a single lease or NULL.
    ///
    /// @param clientid client identifier
    /// @param subnet_id identifier of the subnet that lease must belong to
    ///
    /// @return a pointer to the lease (or NULL if a lease is not found)
    virtual Lease4Ptr getLease4(const ClientId& clientid,
                                SubnetID subnet_id) const;

    /// @brief Returns existing IPv6 lease for a given IPv6 address.
    ///
140 141 142 143
    /// This function returns a copy of the lease. The modification in the
    /// return lease does not affect the instance held in the lease storage.
    ///
    /// @param addr An address of the searched lease.
144 145
    ///
    /// @return smart pointer to the lease (or NULL if a lease is not found)
146
    virtual Lease6Ptr getLease6(const isc::asiolink::IOAddress& addr) const;
147 148 149

    /// @brief Returns existing IPv6 lease for a given DUID+IA combination
    ///
Tomek Mrugalski's avatar
Tomek Mrugalski committed
150 151
    /// @todo Not implemented yet
    ///
152 153 154 155
    /// @param duid client DUID
    /// @param iaid IA identifier
    ///
    /// @return collection of IPv6 leases
156
    virtual Lease6Collection getLease6(const DUID& duid, uint32_t iaid) const;
157

158
    /// @brief Returns existing IPv6 lease for a given DUID/IA/subnet-id tuple
159
    ///
160 161
    /// This function returns a copy of the lease. The modification in the
    /// return lease does not affect the instance held in the lease storage.
Tomek Mrugalski's avatar
Tomek Mrugalski committed
162
    ///
163 164 165 166 167
    /// @param duid client DUID
    /// @param iaid IA identifier
    /// @param subnet_id identifier of the subnet the lease must belong to
    ///
    /// @return smart pointer to the lease (or NULL if a lease is not found)
168 169
    virtual Lease6Ptr getLease6(const DUID& duid, uint32_t iaid,
                                SubnetID subnet_id) const;
170 171 172

    /// @brief Updates IPv4 lease.
    ///
173 174
    /// @warning This function does not validate the pointer to the lease.
    /// It is caller's responsibility to pass the valid pointer.
Tomek Mrugalski's avatar
Tomek Mrugalski committed
175
    ///
176 177 178
    /// @param lease4 The lease to be updated.
    ///
    /// If no such lease is present, an exception will be thrown.
179
    virtual void updateLease4(const Lease4Ptr& lease4);
180

181
    /// @brief Updates IPv6 lease.
182
    ///
183 184
    /// @warning This function does not validate the pointer to the lease.
    /// It is caller's responsibility to pass the valid pointer.
Tomek Mrugalski's avatar
Tomek Mrugalski committed
185
    ///
186
    /// @param lease6 The lease to be updated.
187 188
    ///
    /// If no such lease is present, an exception will be thrown.
189
    virtual void updateLease6(const Lease6Ptr& lease6);
190 191 192

    /// @brief Deletes a lease.
    ///
193 194
    /// @param addr Address of the lease to be deleted. (This can be IPv4 or
    ///        IPv6.)
195 196
    ///
    /// @return true if deletion was successful, false if no such lease exists
197
    virtual bool deleteLease(const isc::asiolink::IOAddress& addr);
198

199 200 201 202 203 204 205 206 207
    /// @brief Return backend type
    ///
    /// Returns the type of the backend.
    ///
    /// @return Type of the backend.
    virtual std::string getType() const {
        return (std::string("memfile"));
    }

208 209
    /// @brief Returns backend name.
    ///
210
    /// For now, memfile can only store data in memory.
211 212 213
    ///
    /// @return Name of the backend.
    virtual std::string getName() const {
214
        return ("memory");
215
    }
216 217 218 219

    /// @brief Returns description of the backend.
    ///
    /// This description may be multiline text that describes the backend.
220 221 222
    ///
    /// @return Description of the backend.
    virtual std::string getDescription() const;
223 224

    /// @brief Returns backend version.
225 226 227
    ///
    /// @return Version number as a pair of unsigned integers.  "first" is the
    ///         major version number, "second" the minor number.
228 229 230 231 232 233 234 235 236 237 238 239 240 241 242
    virtual std::pair<uint32_t, uint32_t> getVersion() const {
        return (std::make_pair(1, 0));
    }

    /// @brief Commit Transactions
    ///
    /// Commits all pending database operations.  On databases that don't
    /// support transactions, this is a no-op.
    virtual void commit();

    /// @brief Rollback Transactions
    ///
    /// Rolls back all pending database operations.  On databases that don't
    /// support transactions, this is a no-op.
    virtual void rollback();
243 244 245

protected:

246 247 248 249 250 251 252 253 254
    // This is a multi-index container, which holds elements that can
    // be accessed using different search indexes.
    typedef boost::multi_index_container<
        // It holds pointers to Lease6 objects.
        Lease6Ptr,
        boost::multi_index::indexed_by<
            // Specification of the first index starts here.
            // This index sorts leases by IPv6 addresses represented as
            // IOAddress objects.
255 256
            boost::multi_index::ordered_unique<
                boost::multi_index::member<Lease, isc::asiolink::IOAddress, &Lease::addr_>
257 258 259 260 261 262 263 264 265 266
            >,

            // Specification of the second index starts here.
            boost::multi_index::ordered_unique<
                // This is a composite index that will be used to search for
                // the lease using three attributes: DUID, IAID, Subnet Id.
                boost::multi_index::composite_key<
                    Lease6,
                    // The DUID value can't be directly accessed from the Lease6
                    // object because it is wrapped with the DUID object (actually
267 268 269 270
                    // pointer to this object). Therefore we need to use
                    // KeyFromKeyExtractor class to extract the DUID value from
                    // this cascaded structure.
                    KeyFromKeyExtractor<
271 272 273 274 275 276 277 278 279 280 281 282 283
                        // The value of the DUID is accessed by the getDuid() method
                        // from the DUID object.
                        boost::multi_index::const_mem_fun<DUID, std::vector<uint8_t>,
                                                          &DUID::getDuid>,
                        // The DUID object is stored in the duid_ member of the
                        // Lease6 object.
                        boost::multi_index::member<Lease6, DuidPtr, &Lease6::duid_>
                    >,
                    // The two other ingredients of this index are IAID and
                    // subnet id.
                    boost::multi_index::member<Lease6, uint32_t, &Lease6::iaid_>,
                    boost::multi_index::member<Lease, SubnetID, &Lease::subnet_id_>
                >
284 285
            >
        >
286 287 288 289 290 291 292 293 294 295 296 297 298 299 300
     > Lease6Storage; // Specify the type name of this container.

    // This is a multi-index container, which holds elements that can
    // be accessed using different search indexes.
    typedef boost::multi_index_container<
        // It holds pointers to Lease4 objects.
        Lease4Ptr, 
        // Specification of search indexes starts here.
        boost::multi_index::indexed_by<
            // Specification of the first index starts here.
            // This index sorts leases by IPv4 addresses represented as
            // IOAddress objects.
            boost::multi_index::ordered_unique<
                // The IPv4 address are held in addr_ members that belong to
                // Lease class.
301
                boost::multi_index::member<Lease, isc::asiolink::IOAddress, &Lease::addr_>
302
            >,
303 304

            // Specification of the second index starts here.
305
            boost::multi_index::ordered_unique<
306 307
                // This is a composite index that combines two attributes of the
                // Lease4 object: hardware address and subnet id.
308 309
                boost::multi_index::composite_key<
                    Lease4,
310 311
                    // The hardware address is held in the hwaddr_ member of the
                    // Lease4 object.
312 313
                    boost::multi_index::member<Lease4, std::vector<uint8_t>,
                                               &Lease4::hwaddr_>,
314 315 316 317
                    // The subnet id is held in the subnet_id_ member of Lease4
                    // class. Note that the subnet_id_ is defined in the base
                    // class (Lease) so we have to point to this class rather
                    // than derived class: Lease4.
318 319 320
                    boost::multi_index::member<Lease, SubnetID, &Lease::subnet_id_>
                >
            >,
321 322

            // Specification of the third index starts here.
323
            boost::multi_index::ordered_unique<
324 325
                // This is a composite index that uses two values to search for a
                // lease: client id and subnet id.
326 327
                boost::multi_index::composite_key<
                    Lease4,
328 329
                    // The client id value is not directly accessible through the
                    // Lease4 object as it is wrapped with the ClientIdPtr object.
330 331 332 333
                    // Therefore we use the KeyFromKeyExtractor class to access
                    // client id through this cascaded structure. The client id
                    // is used as an index value.
                    KeyFromKeyExtractor<
334 335
                        // Specify that the vector holding client id value can be obtained
                        // from the ClientId object.
336 337
                        boost::multi_index::const_mem_fun<ClientId, std::vector<uint8_t>,
                                                          &ClientId::getClientId>,
338 339
                        // Specify that the ClientId object (actually pointer to it) can
                        // be accessed by the client_id_ member of Lease4 class.
340 341
                        boost::multi_index::member<Lease4, ClientIdPtr, &Lease4::client_id_>
                    >,
342
                    // The subnet id is accessed through the subnet_id_ member.
343 344
                    boost::multi_index::member<Lease, uint32_t, &Lease::subnet_id_>
                >
345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373
            >,

            // Specification of the fourth index starts here.
            boost::multi_index::ordered_unique<
                // This is a composite index that uses two values to search for a
                // lease: client id and subnet id.
                boost::multi_index::composite_key<
                    Lease4,
                    // The client id value is not directly accessible through the
                    // Lease4 object as it is wrapped with the ClientIdPtr object.
                    // Therefore we use the KeyFromKeyExtractor class to access
                    // client id through this cascaded structure. The client id
                    // is used as an index value.
                    KeyFromKeyExtractor<
                        // Specify that the vector holding client id value can be obtained
                        // from the ClientId object.
                        boost::multi_index::const_mem_fun<ClientId, std::vector<uint8_t>,
                                                          &ClientId::getClientId>,
                        // Specify that the ClientId object (actually pointer to it) can
                        // be accessed by the client_id_ member of Lease4 class.
                        boost::multi_index::member<Lease4, ClientIdPtr, &Lease4::client_id_>
                    >,
                    // The hardware address is held in the hwaddr_ member of the
                    // Lease4 object.
                    boost::multi_index::member<Lease4, std::vector<uint8_t>,
                                               &Lease4::hwaddr_>,
                    // The subnet id is accessed through the subnet_id_ member.
                    boost::multi_index::member<Lease, SubnetID, &Lease::subnet_id_>
                >
374 375
            >
        >
376
    > Lease4Storage; // Specify the type name for this container.
377 378 379 380 381

    /// @brief stores IPv4 leases
    Lease4Storage storage4_;

    /// @brief stores IPv6 leases
382 383 384 385 386 387
    Lease6Storage storage6_;
};

}; // end of isc::dhcp namespace
}; // end of isc namespace

388
#endif // MEMFILE_LEASE_MGR