lease_file_loader.h

Go to the documentation of this file.

// Copyright (C) 2015-2024 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 LEASE_FILE_LOADER_H
#define LEASE_FILE_LOADER_H
 
#include <dhcpsrv/dhcpsrv_log.h>
#include <dhcpsrv/memfile_lease_storage.h>
#include <util/versioned_csv_file.h>
#include <dhcpsrv/sanity_checker.h>
 
#include <boost/scoped_ptr.hpp>
#include <boost/shared_ptr.hpp>
 
namespace isc {
namespace dhcp {
 
class LeaseFileLoader {
public:
 
    template<typename LeaseObjectType, typename LeaseFileType,
             typename StorageType>
    static void load(LeaseFileType& lease_file, StorageType& storage,
                     const uint32_t max_errors = 0,
                     const bool close_file_on_exit = true) {
 
        LOG_INFO(dhcpsrv_logger, DHCPSRV_MEMFILE_LEASE_FILE_LOAD)
            .arg(lease_file.getFilename());
 
        // Reopen the file, as we don't know whether the file is open
        // and we also don't know its current state.
        lease_file.close();
        lease_file.open();
 
        // Create lease sanity checker if checking is enabled.
        boost::scoped_ptr<SanityChecker> lease_checker;
        if (SanityChecker::leaseCheckingEnabled(false)) {
            // Since lease file is loaded during the configuration,
            // we have to use staging config, rather than current
            // config for this (false = staging).
            lease_checker.reset(new SanityChecker());
        }
 
        boost::shared_ptr<LeaseObjectType> lease;
        // Track the number of corrupted leases.
        uint32_t errcnt = 0;
        while (true) {
            // Unable to parse the lease.
            if (!lease_file.next(lease)) {
                LOG_ERROR(dhcpsrv_logger, DHCPSRV_MEMFILE_LEASE_LOAD_ROW_ERROR)
                            .arg(lease_file.getReads())
                            .arg(lease_file.getReadMsg());
 
                // A value of 0 indicates that we don't return
                // until the whole file is parsed, even if errors occur.
                // Otherwise, check if we have exceeded the maximum number
                // of errors and throw an exception if we have.
                if (max_errors && (++errcnt > max_errors)) {
                    // If we break parsing the CSV file because of too many
                    // errors, it doesn't make sense to keep the file open.
                    // This is because the caller wouldn't know where we
                    // stopped parsing and where the internal file pointer
                    // is. So, there are probably no cases when the caller
                    // would continue to use the open file.
                    lease_file.close();
                    isc_throw(util::CSVFileError, "exceeded maximum number of"
                              " failures " << max_errors << " to read a lease"
                              " from the lease file "
                              << lease_file.getFilename());
                }
                // Skip the corrupted lease.
                continue;
            }
 
            // Lease was found and we successfully parsed it.
            if (lease) {
                LOG_DEBUG(dhcpsrv_logger, DHCPSRV_DBG_TRACE_DETAIL_DATA,
                          DHCPSRV_MEMFILE_LEASE_LOAD)
                    .arg(lease->toText());
 
                if (lease_checker)  {
                    // If the lease is insane the checker will reset the lease pointer.
                    // As lease file is loaded during the configuration, we have
                    // to use staging config, rather than current config for this
                    // (false = staging).
                    lease_checker->checkLease(lease, false);
                    if (!lease) {
                        continue;
                    }
                }
 
                // Check if this lease exists.
                typename StorageType::iterator lease_it =
                    storage.find(lease->addr_);
                // The lease doesn't exist yet. Insert the lease if
                // it has a positive valid lifetime.
                if (lease_it == storage.end()) {
                    if (lease->valid_lft_ > 0) {
                        storage.insert(lease);
                    }
                } else {
                    // The lease exists. If the new entry has a valid
                    // lifetime of 0 it is an indication to remove the
                    // existing entry. Otherwise, we update the lease.
                    if (lease->valid_lft_ == 0) {
                        storage.erase(lease_it);
 
                    } else {
                        // Use replace to re-index leases on update.
                        storage.replace(lease_it, lease);
                    }
                }
 
            } else {
                // Being here means that we hit the end of file.
                break;
 
            }
        }
 
        if (lease_file.needsConversion()) {
            LOG_WARN(dhcpsrv_logger,
                     (lease_file.getInputSchemaState()
                      == util::VersionedCSVFile::NEEDS_UPGRADE
                      ?  DHCPSRV_MEMFILE_NEEDS_UPGRADING
                      : DHCPSRV_MEMFILE_NEEDS_DOWNGRADING))
                     .arg(lease_file.getFilename())
                     .arg(lease_file.getSchemaVersion());
        }
 
        if (close_file_on_exit) {
            lease_file.close();
        }
    }
 
    template<typename LeaseObjectType, typename LeaseFileType,
             typename StorageType>
    static void write(LeaseFileType& lease_file, const StorageType& storage) {
        // Reopen the file, as we don't know whether the file is open
        // and we also don't know its current state.
        lease_file.close();
        lease_file.open();
 
        // Iterate over the storage area writing out the leases
        for (auto const& lease : storage) {
            try {
                lease_file.append(*lease);
            } catch (const isc::Exception&) {
                // Close the file
                lease_file.close();
                throw;
            }
        }
 
        // Close the file
        lease_file.close();
    }
};
 
}  // namespace dhcp
}  // namespace isc
 
#endif // LEASE_FILE_LOADER_H