logging.cc 8.29 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Copyright (C) 2014 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.

#include <cc/data.h>
#include <dhcpsrv/logging.h>
#include <boost/foreach.hpp>
#include <boost/lexical_cast.hpp>
#include <log/logger_specification.h>
#include <log/logger_manager.h>
Tomek Mrugalski's avatar
Tomek Mrugalski committed
21
#include <log/logger_name.h>
22
23
24
25
26
27
28
29

using namespace isc::data;
using namespace isc::log;

namespace isc {
namespace dhcp {

LogConfigParser::LogConfigParser(const ConfigurationPtr& storage)
Tomek Mrugalski's avatar
Tomek Mrugalski committed
30
    :config_(storage), verbose_(false) {
31
    if (!storage) {
Tomek Mrugalski's avatar
Tomek Mrugalski committed
32
        isc_throw(BadValue, "LogConfigParser needs a pointer to the "
33
34
35
36
                  "configuration, so parsed data can be stored there");
    }
}

37
void LogConfigParser::parseConfiguration(const isc::data::ConstElementPtr& loggers,
Tomek Mrugalski's avatar
Tomek Mrugalski committed
38
39
                                         bool verbose) {
    verbose_ = verbose;
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

    // Iterate over all entries in "Logging/loggers" list
    BOOST_FOREACH(ConstElementPtr logger, loggers->listValue()) {
        parseConfigEntry(logger);
    }
}

void LogConfigParser::parseConfigEntry(isc::data::ConstElementPtr entry) {
    if (!entry) {
        // This should not happen, but let's be on the safe side and check
        return;
    }

    if (!config_) {
        isc_throw(BadValue, "configuration storage not set, can't parse logger config.");
    }

    LoggingInfo info;

    // Get a name
    isc::data::ConstElementPtr name_ptr = entry->get("name");
    if (!name_ptr) {
        isc_throw(BadValue, "loggers entry does not have a mandatory 'name' "
                  "element (" << entry->getPosition() << ")");
    }
    info.name_ = name_ptr->stringValue();

    // Get severity
    isc::data::ConstElementPtr severity_ptr = entry->get("severity");
    if (!name_ptr) {
        isc_throw(BadValue, "loggers entry does not have a mandatory "
                  "'severity' element (" << entry->getPosition() << ")");
    }
    try {
        info.severity_ = isc::log::getSeverity(severity_ptr->stringValue().c_str());
    } catch (const std::exception& ex) {
Tomek Mrugalski's avatar
Tomek Mrugalski committed
76
77
78
        isc_throw(BadValue, "Unsupported severity value '"
                  << severity_ptr->stringValue() << "' ("
                  << severity_ptr->getPosition() << ")");
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
    }

    // Get debug logging level
    info.debuglevel_ = 0;
    isc::data::ConstElementPtr debuglevel_ptr = entry->get("debuglevel");

    // It's ok to not have debuglevel, we'll just assume its least verbose
    // (0) level.
    if (debuglevel_ptr) {
        try {
            info.debuglevel_ = boost::lexical_cast<int>(debuglevel_ptr->str());
            if ( (info.debuglevel_ < 0) || (info.debuglevel_ > 99) ) {
                // Comment doesn't matter, it is caught several lines below
                isc_throw(BadValue, "");
            }
        } catch (...) {
Tomek Mrugalski's avatar
Tomek Mrugalski committed
95
96
97
            isc_throw(BadValue, "Unsupported debuglevel value '"
                      << debuglevel_ptr->stringValue()
                      << "', expected 0-99 ("
98
99
100
101
                      << debuglevel_ptr->getPosition() << ")");
        }
    }

Tomek Mrugalski's avatar
Tomek Mrugalski committed
102
103
104
105
106
107
108
109
    // We want to follow the normal path, so it could catch parsing errors even
    // when verbose mode is enabled. If it is, just override whatever was parsed
    // in the config file.
    if (verbose_) {
        info.severity_ = isc::log::DEBUG;
        info.debuglevel_ = 99;
    }

110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
    isc::data::ConstElementPtr output_options = entry->get("output_options");

    if (output_options) {
        parseOutputOptions(info.destinations_, output_options);
    }
    
    config_->logging_info_.push_back(info);
}

void LogConfigParser::parseOutputOptions(std::vector<LoggingDestination>& destination,
                                         isc::data::ConstElementPtr output_options) {
    if (!output_options) {
        isc_throw(BadValue, "Missing 'output_options' structure in 'loggers'");
    }
    BOOST_FOREACH(ConstElementPtr output_option, output_options->listValue()) {

        LoggingDestination dest;

        isc::data::ConstElementPtr output = output_option->get("output");
        if (!output) {
            isc_throw(BadValue, "output_options entry does not have a mandatory 'output' "
                      "element (" << output_option->getPosition() << ")");
        }
        dest.output_ = output->stringValue();

        isc::data::ConstElementPtr maxver_ptr = output_option->get("maxver");
        if (maxver_ptr) {
            dest.maxver_ = boost::lexical_cast<int>(maxver_ptr->str());
        }

        isc::data::ConstElementPtr maxsize_ptr = output_option->get("maxsize");
        if (maxsize_ptr) {
            dest.maxsize_ = boost::lexical_cast<uint64_t>(maxsize_ptr->str());
        }

        destination.push_back(dest);
    }
}

void LogConfigParser::applyConfiguration() {

    static const std::string STDOUT = "stdout";
    static const std::string STDERR = "stderr";
    static const std::string SYSLOG = "syslog";
    static const std::string SYSLOG_COLON = "syslog:";

    // Set locking directory to /tmp
    setenv("B10_LOCKFILE_DIR_FROM_BUILD", "/tmp", 1);

    // Now iterate through all specified loggers
    for (LoggingInfoStorage::const_iterator it = config_->logging_info_.begin();
         it != config_->logging_info_.end(); ++it) {

        // Prepare the objects to define the logging specification
        LoggerSpecification spec(it->name_,
                                 it->severity_,
                                 it->debuglevel_);
        OutputOption option;

        for (std::vector<LoggingDestination>::const_iterator dest = it->destinations_.begin();
             dest != it->destinations_.end(); ++dest) {
            
            // Set up output option according to destination specification
            if (dest->output_ == STDOUT) {
                option.destination = OutputOption::DEST_CONSOLE;
                option.stream = OutputOption::STR_STDOUT;

            } else if (dest->output_ == STDERR) {
                option.destination = OutputOption::DEST_CONSOLE;
                option.stream = OutputOption::STR_STDERR;

            } else if (dest->output_ == SYSLOG) {
                option.destination = OutputOption::DEST_SYSLOG;
                // Use default specified in OutputOption constructor for the
                // syslog destination

            } else if (dest->output_.find(SYSLOG_COLON) == 0) {
                option.destination = OutputOption::DEST_SYSLOG;
                // Must take account of the string actually being "syslog:"
                if (dest->output_ == SYSLOG_COLON) {
                    // The expected syntax is syslog:facility. User skipped
Tomek Mrugalski's avatar
Tomek Mrugalski committed
191
192
                    // the logging name, so we'll just use the default ("kea")
                    option.facility = isc::log::getDefaultRootLoggerName();
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
                    
                } else {
                    // Everything else in the string is the facility name
                    option.facility = dest->output_.substr(SYSLOG_COLON.size());
                }

            } else {
                // Not a recognised destination, assume a file.
                option.destination = OutputOption::DEST_FILE;
                option.filename = dest->output_;
            }

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

        LoggerManager manager;
        manager.process(spec);
    }
}

Tomek Mrugalski's avatar
Tomek Mrugalski committed
214
215
216
void LogConfigParser::applyDefaultConfiguration(bool verbose) {
    LoggerSpecification spec("kea", (verbose?isc::log::DEBUG : isc::log::INFO),
                             (verbose?99:0));
217
218
219
220
221
222
223
224
225
226
227
228
229

    OutputOption option;
    option.destination = OutputOption::DEST_CONSOLE;
    option.stream = OutputOption::STR_STDOUT;

    spec.addOutputOption(option);

    LoggerManager manager;
    manager.process(spec);
}

} // namespace isc::dhcp
} // namespace isc