lfc_controller.cc 13 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14
// Copyright (C) 2015  Internet Systems Consortium, Inc. ("ISC")
//
// 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.

15
#include <lfc/lfc_controller.h>
16
#include <lfc/lfc_log.h>
17
#include <util/pid_file.h>
18
#include <exceptions/exceptions.h>
19 20 21 22 23
#include <dhcpsrv/csv_lease_file4.h>
#include <dhcpsrv/csv_lease_file6.h>
#include <dhcpsrv/memfile_lease_storage.h>
#include <dhcpsrv/lease_mgr.h>
#include <dhcpsrv/lease_file_loader.h>
24 25
#include <log/logger_manager.h>
#include <log/logger_name.h>
Shawn Routhier's avatar
Shawn Routhier committed
26
#include <config.h>
27

28
#include <iostream>
29 30
#include <sstream>
#include <unistd.h>
31
#include <stdlib.h>
32
#include <cerrno>
33 34

using namespace std;
35
using namespace isc::util;
36
using namespace isc::dhcp;
37
using namespace isc::log;
38

39 40 41 42 43
namespace {
/// @brief Maximum number of errors to allow when reading leases from the file.
const uint32_t MAX_LEASE_ERRORS = 100;
}; // namespace anonymous

44 45 46 47 48
namespace isc {
namespace lfc {

/// @brief Defines the application name, it may be used to locate
/// configuration data and appears in log statements.
49
const char* LFCController::lfc_app_name_ = "DhcpLFC";
50 51

/// @brief Defines the executable name.
52
const char* LFCController::lfc_bin_name_ = "kea-lfc";
53

54
LFCController::LFCController()
55
    : protocol_version_(0), verbose_(false), config_file_(""), previous_file_(""),
Shawn Routhier's avatar
Shawn Routhier committed
56
      copy_file_(""), output_file_(""), finish_file_(""), pid_file_("") {
57 58
}

59
LFCController::~LFCController() {
60 61 62
}

void
63
LFCController::launch(int argc, char* argv[], const bool test_mode) {
64
    bool do_rotate = true;
65

66 67 68 69 70 71 72 73 74
    // If we are running in test mode use the environment variables
    // else use our defaults
    if (test_mode) {
        initLogger();
    }
    else {
        OutputOption option;
        LoggerManager manager;

75
        initLogger(lfc_app_name_, INFO, 0, NULL, false);
76

77 78 79 80 81 82 83 84 85 86 87 88 89 90
        // Prepare the objects to define the logging specification
        LoggerSpecification spec(getRootLoggerName(),
                                 keaLoggerSeverity(INFO),
                                 keaLoggerDbglevel(0));

        // We simply want the default syslog option
        option.destination = OutputOption::DEST_SYSLOG;

        // ... and set the destination
        spec.addOutputOption(option);

        manager.process(spec);
    }

91 92 93 94 95 96 97
    try {
        parseArgs(argc, argv);
    } catch (const InvalidUsage& ex) {
        usage(ex.what());
        throw;  // rethrow it
    }

98 99
    // Now that we have parsed the arguments we can
    // update the logging level.
100
    if (verbose_) {
101
        setDefaultLoggingOutput(verbose_);
102
    }
103

104
    LOG_INFO(lfc_logger, LFC_START);
105

106 107
    // verify we are the only instance
    PIDFile pid_file(pid_file_);
108 109

    try {
110
        if (pid_file.check()) {
111
            // Already running instance, bail out
112
            LOG_FATAL(lfc_logger, LFC_RUNNING);
113 114
            return;
        }
115

116
        // create the pid file for this instance
117 118
        pid_file.write();
    } catch (const PIDFileError& pid_ex) {
119
        LOG_FATAL(lfc_logger, LFC_FAIL_PID_CREATE).arg(pid_ex.what());
120 121 122
        return;
    }

123 124 125 126 127
    // If we don't have a finish file do the processing.  We
    // don't know the exact type of the finish file here but
    // all we care about is if it exists so that's okay
    CSVFile lf_finish(getFinishFile());
    if (!lf_finish.exists()) {
128 129 130
        LOG_INFO(lfc_logger, LFC_PROCESSING)
          .arg(previous_file_)
          .arg(copy_file_);
131 132

        try {
133
            if (getProtocolVersion() == 4) {
134 135 136 137 138 139
                processLeases<Lease4, CSVLeaseFile4, Lease4Storage>();
            } else {
                processLeases<Lease6, CSVLeaseFile6, Lease6Storage>();
            }
        } catch (const isc::Exception& proc_ex) {
            // We don't want to do the cleanup but do want to get rid of the pid
140
            do_rotate = false;
141
            LOG_FATAL(lfc_logger, LFC_FAIL_PROCESS).arg(proc_ex.what());
142
        }
143
    }
144

145
    // If do_rotate is true We either already had a finish file or
146 147
    // were able to create one.  We now want to do the file cleanup,
    // we don't want to return after the catch as we
148
    // still need to cleanup the pid file
149
    if (do_rotate) {
150
        LOG_INFO(lfc_logger, LFC_ROTATING);
151

152
        try {
153
            fileRotate();
154
        } catch (const RunTimeFail& run_ex) {
155
          LOG_FATAL(lfc_logger, LFC_FAIL_ROTATE).arg(run_ex.what());
156
        }
157
    }
158 159

    // delete the pid file for this instance
160 161 162
    try {
        pid_file.deleteFile();
    } catch (const PIDFileError& pid_ex) {
163
          LOG_FATAL(lfc_logger, LFC_FAIL_PID_DEL).arg(pid_ex.what());
164
    }
165

166
    LOG_INFO(lfc_logger, LFC_TERMINATE);
167 168 169
}

void
170
LFCController::parseArgs(int argc, char* argv[]) {
171 172
    int ch;

173 174
    opterr = 0;
    optind = 1;
175
    while ((ch = getopt(argc, argv, ":46dvVp:x:i:o:c:f:")) != -1) {
176
        switch (ch) {
Shawn Routhier's avatar
Shawn Routhier committed
177
        case '4':
178
            // Process DHCPv4 lease files.
179
            protocol_version_ = 4;
180 181
            break;

Shawn Routhier's avatar
Shawn Routhier committed
182
        case '6':
183
            // Process DHCPv6 lease files.
184
            protocol_version_ = 6;
185 186
            break;

Shawn Routhier's avatar
Shawn Routhier committed
187
        case 'v':
188
            // Print just Kea vesion and exit.
Shawn Routhier's avatar
Shawn Routhier committed
189
            std::cout << getVersion(false) << std::endl;
190 191
            exit(EXIT_SUCCESS);

Shawn Routhier's avatar
Shawn Routhier committed
192
        case 'V':
193
            // Print extended  Kea vesion and exit.
Shawn Routhier's avatar
Shawn Routhier committed
194
            std::cout << getVersion(true) << std::endl;
195 196
            exit(EXIT_SUCCESS);

Shawn Routhier's avatar
Shawn Routhier committed
197 198 199 200 201 202
        case 'd':
            // Verbose output.
            verbose_ = true;
            break;

        case 'p':
203 204 205 206 207 208 209 210 211
            // PID file name.
            if (optarg == NULL) {
                isc_throw(InvalidUsage, "PID file name missing");
            }
            pid_file_ = optarg;
            break;

        case 'x':
            // Previous (or ex) file name.
Shawn Routhier's avatar
Shawn Routhier committed
212
            if (optarg == NULL) {
213
                isc_throw(InvalidUsage, "Previous (ex) file name missing");
Shawn Routhier's avatar
Shawn Routhier committed
214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234
            }
            previous_file_ = optarg;
            break;

        case 'i':
            // Copy file name.
            if (optarg == NULL) {
                isc_throw(InvalidUsage, "Copy file name missing");
            }
            copy_file_ = optarg;
            break;

        case 'o':
            // Output file name.
            if (optarg == NULL) {
                isc_throw(InvalidUsage, "Output file name missing");
            }
            output_file_ = optarg;
            break;

        case 'f':
235
            // Finish file name.
Shawn Routhier's avatar
Shawn Routhier committed
236 237 238 239 240 241 242
            if (optarg == NULL) {
                isc_throw(InvalidUsage, "Finish file name missing");
            }
            finish_file_ = optarg;
            break;

        case 'c':
243
            // Configuration file name
Shawn Routhier's avatar
Shawn Routhier committed
244 245 246 247 248 249
            if (optarg == NULL) {
                isc_throw(InvalidUsage, "Configuration file name missing");
            }
            config_file_ = optarg;
            break;

250
        case 'h':
Shawn Routhier's avatar
Shawn Routhier committed
251
            usage("");
252 253 254 255 256 257 258 259 260
            exit(EXIT_SUCCESS);

        case '?':
            // Unknown argument
            isc_throw(InvalidUsage, "Unknown argument");

        case ':':
            // Missing option argument
            isc_throw(InvalidUsage, "Missing option argument");
261 262

        default:
263 264 265
            // I don't think we should get here as the unknown arguments
            // and missing options cases should cover everything else
            isc_throw(InvalidUsage, "Invalid command line");
Shawn Routhier's avatar
Shawn Routhier committed
266
        }
267 268 269 270 271 272 273
    }

    // Check for extraneous parameters.
    if (argc > optind) {
        isc_throw(InvalidUsage, "Extraneous parameters.");
    }

274
    if (protocol_version_ == 0) {
275 276 277
        isc_throw(InvalidUsage, "DHCP version required");
    }

278 279 280 281
    if (pid_file_.empty()) {
        isc_throw(InvalidUsage, "PID file not specified");
    }

282
    if (previous_file_.empty()) {
Shawn Routhier's avatar
Shawn Routhier committed
283
        isc_throw(InvalidUsage, "Previous file not specified");
284 285 286
    }

    if (copy_file_.empty()) {
Shawn Routhier's avatar
Shawn Routhier committed
287
        isc_throw(InvalidUsage, "Copy file not specified");
288 289 290
    }

    if (output_file_.empty()) {
Shawn Routhier's avatar
Shawn Routhier committed
291
        isc_throw(InvalidUsage, "Output file not specified");
292 293
    }

294
    if (finish_file_.empty()) {
Shawn Routhier's avatar
Shawn Routhier committed
295
        isc_throw(InvalidUsage, "Finish file not specified");
296 297
    }

298
    if (config_file_.empty()) {
Shawn Routhier's avatar
Shawn Routhier committed
299
        isc_throw(InvalidUsage, "Config file not specified");
300 301 302
    }

    // If verbose is set echo the input information
303
    if (verbose_) {
304
        std::cout << "Protocol version:    DHCPv" << protocol_version_ << std::endl
305 306 307 308 309 310 311
                  << "Previous or ex lease file: " << previous_file_ << std::endl
                  << "Copy lease file:           " << copy_file_ << std::endl
                  << "Output lease file:         " << output_file_ << std::endl
                  << "Finish file:               " << finish_file_ << std::endl
                  << "Config file:               " << config_file_ << std::endl
                  << "PID file:                  " << pid_file_ << std::endl
                  << std::endl;
312 313 314 315
    }
}

void
316
LFCController::usage(const std::string& text) {
317
    if (!text.empty()) {
318 319 320 321
        std::cerr << "Usage error: " << text << std::endl;
    }

    std::cerr << "Usage: " << lfc_bin_name_ << std::endl
322
              << " [-4|-6] -p file -x file -i file -o file -f file -c file" << std::endl
323
              << "   -4 or -6 clean a set of v4 or v6 lease files" << std::endl
324 325
              << "   -p <file>: PID file" << std::endl
              << "   -x <file>: previous or ex lease file" << std::endl
326 327
              << "   -i <file>: copy of lease file" << std::endl
              << "   -o <file>: output lease file" << std::endl
328
              << "   -f <file>: finish file" << std::endl
329 330 331 332
              << "   -c <file>: configuration file" << std::endl
              << "   -v: print version number and exit" << std::endl
              << "   -V: print extended version inforamtion and exit" << std::endl
              << "   -d: optional, verbose output " << std::endl
333
              << "   -h: print this message " << std::endl
334 335 336
              << std::endl;
}

337
std::string
338 339
LFCController::getVersion(const bool extended) const{
    std::stringstream version_stream;
340

341
    version_stream << VERSION;
342
    if (extended) {
343
        version_stream << std::endl << EXTENDED_VERSION;
344 345
    }

346
    return (version_stream.str());
347 348
}

349
template<typename LeaseObjectType, typename LeaseFileType, typename StorageType>
350 351
void
LFCController::processLeases() const {
352 353 354
    StorageType storage;

    // If a previous file exists read the entries into storage
355
    LeaseFileType lf_prev(getPreviousFile());
356 357 358
    if (lf_prev.exists()) {
        LeaseFileLoader::load<LeaseObjectType>(lf_prev, storage,
                                               MAX_LEASE_ERRORS);
359 360
    }

361
    // Follow that with the copy of the current lease file
362
    LeaseFileType lf_copy(getCopyFile());
363 364 365
    if (lf_copy.exists()) {
        LeaseFileLoader::load<LeaseObjectType>(lf_copy, storage,
                                               MAX_LEASE_ERRORS);
366 367 368
    }

    // Write the result out to the output file
369
    LeaseFileType lf_output(getOutputFile());
370
    LeaseFileLoader::write<LeaseObjectType>(lf_output, storage);
371

372
    // If desired log the stats
373
    LOG_INFO(lfc_logger, LFC_READ_STATS)
374 375 376 377
      .arg(lf_prev.getReadLeases() + lf_copy.getReadLeases())
      .arg(lf_prev.getReads() + lf_copy.getReads())
      .arg(lf_prev.getReadErrs() + lf_copy.getReadErrs());

378
    LOG_INFO(lfc_logger, LFC_WRITE_STATS)
379 380 381 382
      .arg(lf_output.getWriteLeases())
      .arg(lf_output.getWrites())
      .arg(lf_output.getWriteErrs());

383
    // Once we've finished the output file move it to the complete file
384
    if (rename(getOutputFile().c_str(), getFinishFile().c_str()) != 0) {
385 386 387
        isc_throw(RunTimeFail, "Unable to move output (" << output_file_
                  << ") to complete (" << finish_file_
                  << ") error: " << strerror(errno));
388
    }
389 390 391
}

void
392
LFCController::fileRotate() const {
393
    // Remove the old previous file
394
    if ((remove(getPreviousFile().c_str()) != 0) &&
395 396 397 398 399 400
        (errno != ENOENT)) {
        isc_throw(RunTimeFail, "Unable to delete previous file '"
                  << previous_file_ << "' error: " << strerror(errno));
    }

    // Remove the copy file
401
    if ((remove(getCopyFile().c_str()) != 0) &&
402 403 404 405 406 407
        (errno != ENOENT)) {
        isc_throw(RunTimeFail, "Unable to delete copy file '"
                  << copy_file_ << "' error: " << strerror(errno));
    }

    // Rename the finish file to be the previous file
408
    if (rename(finish_file_.c_str(), previous_file_.c_str()) != 0) {
409 410 411
        isc_throw(RunTimeFail, "Unable to move finish (" << finish_file_
                  << ") to previous (" << previous_file_
                  << ") error: " << strerror(errno));
412
    }
413
}
414 415
}; // namespace isc::lfc
}; // namespace isc