4 // Fraunhofer Institute for Open Communication Systems (FOKUS)
5 // Competence Center NETwork research (NET), St. Augustin, GERMANY
6 // Stefan Bund <g0dil@berlios.de>
8 // This program is free software; you can redistribute it and/or modify
9 // it under the terms of the GNU General Public License as published by
10 // the Free Software Foundation; either version 2 of the License, or
11 // (at your option) any later version.
13 // This program is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 // GNU General Public License for more details.
18 // You should have received a copy of the GNU General Public License
19 // along with this program; if not, write to the
20 // Free Software Foundation, Inc.,
21 // 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
24 \brief Target non-inline non-template implementation */
31 #include <boost/format.hpp>
32 #include "ConsoleTarget.hh"
33 #include "../Console/Console.hh"
34 #include "../Console/Sysdir.hh"
35 #include "../membind.hh"
37 //#include "Target.mpp"
39 ///////////////////////////////cc.p////////////////////////////////////////
41 ///////////////////////////////////////////////////////////////////////////
47 SENF_CONSOLE_REGISTER_ENUM_MEMBER( Target, action_t, (ACCEPT)(REJECT) );
51 SENF_CONSOLE_REGISTER_ENUM_MEMBER( TargetRegistry, Level,
52 (VERBOSE)(NOTICE)(MESSAGE)(IMPORTANT)(CRITICAL)(FATAL) );
56 prefix_ senf::log::Target::Target(std::string const & name)
58 namespace kw = senf::console::kw;
60 detail::TargetRegistry::instance().registerTarget(this, name);
61 consoleDir_().add("list", senf::membind(&Target::consoleList, this))
62 .doc("Show routing table\n"
66 " STREAM stream to match, empty to match all streams\n"
67 " AREA area to match, empty to match all targets\n"
68 " LEVEL match messages with level above this. Log levels in increasing order\n"
70 " verbose, notice, message, important, critical, fatal\n"
71 " ACTION action to take: accept or reject");
72 consoleDir_().add("route",
73 boost::function<void (std::string const &, std::string const &,
74 detail::TargetRegistry::Level, action_t, int)>(
76 static_cast<void (Target::*)(
77 std::string const &, std::string const &,
78 unsigned, action_t, int)>(&Target::route),
81 "stream to match or empty to match any stream\n"
82 " use '/sys/log/streams' to list all available streams",
85 "area to match or empty to match any area\n"
86 " use '/sys/log/areas' to list all available areas",
88 .arg("level", "log level, one of: VERBOSE, NOTICE, MESSAGE, IMPORTANT, CRITICAL, FATAL",
89 kw::default_value=detail::TargetRegistry::VERBOSE)
90 .arg("action", "routing action, one of: ACCEPT, REJECT",
91 kw::default_value=ACCEPT)
92 .arg("index", "index at which to insert new rule",
94 .doc("Add routing entry. Log messages are matched against the routing table beginning\n"
95 "with the first entry. The action of the first matching entry determines the\n"
96 "handling of the message.\n"
101 " route all messages to this target.\n"
103 " route \"\" my::Class\n"
104 " route all messages which are in the my::Class area.\n"
106 " route senf::log::Debug \"\" VERBOSE REJECT\n"
107 " route \"\" \"\" VERBOSE\n"
108 " route all messages not in the senf::log::Debug stream to the current area.\n"
110 "The additional optional index argument identifies the position in the routing table\n"
111 "where the new routing entry will be added. Positive numbers count from the\n"
112 "beginning, 0 being the first routing entry. Negative values count from the end.\n");
113 consoleDir_().add("unroute",
114 senf::membind(static_cast<void (Target::*)(int)>(&Target::unroute), this))
115 .arg("index", "index of routing entry to remove")
116 .overloadDoc("Remove routing entry with the given index");
117 consoleDir_().add("unroute",
118 boost::function<void (std::string const &, std::string const &,
119 detail::TargetRegistry::Level, action_t)>(
121 static_cast<void (Target::*)(
122 std::string const &, std::string const &,
123 unsigned, action_t)>(&Target::unroute),
125 .arg("stream", "stream to match or empty to match any stream",
126 kw::default_value="")
127 .arg("area", "area to match or empty to match any area",
128 kw::default_value="")
129 .arg("level", "log level, one of: VERBOSE, NOTICE, MESSAGE, IMPORTANT, CRITICAL, FATAL",
130 kw::default_value=detail::TargetRegistry::VERBOSE)
131 .arg("action", "routing action, one of: ACCEPT, REJECT",
132 kw::default_value=ACCEPT)
133 .overloadDoc("Remove the routing entry matching the specified arguments.");
134 consoleDir_().add("flush", senf::membind(&Target::flush, this))
135 .doc("Remove all routing entries clearing the routing table. This will disable all\n"
136 "logging output on this target.");
139 prefix_ senf::log::Target::~Target()
141 while( ! rib_.empty()) {
142 // This is slow but simplifies the area cache handling and removing a target should be
144 RIB::reverse_iterator i (rib_.rbegin());
145 unroute(i->stream_, i->area_, i->level_, i->action_);
147 detail::TargetRegistry::instance().unregisterTarget(this);
150 prefix_ void senf::log::Target::route(std::string const & stream, std::string const & area,
151 unsigned level, action_t action, int index)
153 detail::StreamBase const * s (0);
154 if (! stream.empty()) {
155 s = StreamRegistry::instance().lookup(stream);
157 throw InvalidStreamException();
159 detail::AreaBase const * a (0);
160 if (! area.empty()) {
161 a = AreaRegistry::instance().lookup(area);
163 throw InvalidAreaException();
165 route(s, a, level, action, index);
168 prefix_ void senf::log::Target::unroute(std::string const & stream, std::string const & area,
169 unsigned level, action_t action)
171 detail::StreamBase const * s (0);
172 if (! stream.empty()) {
173 s = StreamRegistry::instance().lookup(stream);
175 throw InvalidStreamException();
177 detail::AreaBase const * a (0);
178 if (! area.empty()) {
179 a = AreaRegistry::instance().lookup(area);
181 throw InvalidAreaException();
183 unroute(s, a, level, action);
186 prefix_ void senf::log::Target::unroute(int index)
192 if (RIB::size_type(-index) >= rib_.size())
196 std::advance(i, index);
199 if (RIB::size_type(index+1) >= rib_.size()) {
204 std::advance(i, index);
209 RoutingEntry entry (*i);
211 if (entry.action_ == ACCEPT)
212 updateRoutingCache(entry.stream_, entry.area_);
215 prefix_ void senf::log::Target::flush()
219 RIB::const_iterator i (old.begin());
220 RIB::const_iterator const i_end (old.end());
221 for (; i != i_end; ++i)
222 if (i->action_ == ACCEPT)
223 updateRoutingCache(i->stream_, i->area_);
226 ////////////////////////////////////////
229 prefix_ senf::log::detail::TargetRegistry::TargetRegistry()
230 : fallbackRouting_(true)
232 namespace kw = senf::console::kw;
234 console::sysdir().add("log", consoleDir_());
235 consoleDir_().add("areas", senf::membind(&TargetRegistry::consoleAreas, this))
236 .doc("List all areas");
237 consoleDir_().add("streams", senf::membind(&TargetRegistry::consoleStreams, this))
238 .doc("List all streams");
239 consoleDir_().add("message", senf::membind(&TargetRegistry::consoleWrite, this))
240 .arg("stream", "stream to write message to",
241 kw::default_value = "senf::log::Debug")
242 .arg("area","area to write message to",
243 kw::default_value = "senf::log::DefaultArea")
244 .arg("level", "log level",
245 kw::default_value = MESSAGE)
246 .arg("message", "message to write")
247 .doc("Write log message");
250 prefix_ void senf::log::detail::TargetRegistry::consoleAreas(std::ostream & os)
252 AreaRegistry::iterator i (AreaRegistry::instance().begin());
253 AreaRegistry::iterator const i_end (AreaRegistry::instance().end());
254 for (; i != i_end; ++i)
258 prefix_ void senf::log::detail::TargetRegistry::consoleStreams(std::ostream & os)
260 StreamRegistry::iterator i (StreamRegistry::instance().begin());
261 StreamRegistry::iterator const i_end (StreamRegistry::instance().end());
262 for (; i != i_end; ++i)
266 prefix_ void senf::log::detail::TargetRegistry::consoleWrite(std::string const & stream,
267 std::string const & area,
269 std::string const & msg)
271 detail::StreamBase const * s (StreamRegistry::instance().lookup(stream));
273 throw Target::InvalidStreamException();
274 detail::AreaBase const * a (AreaRegistry::instance().lookup(area));
276 throw Target::InvalidAreaException();
277 write(*s, *a, level, msg);
280 ////////////////////////////////////////
283 prefix_ void senf::log::Target::route(detail::StreamBase const * stream,
284 detail::AreaBase const * area, unsigned level,
285 action_t action, int index)
289 if (RIB::size_type(-index-1) >= rib_.size())
293 std::advance(i, index + 1 );
296 if (RIB::size_type(index) >= rib_.size())
300 std::advance(i, index);
303 rib_.insert(i, RoutingEntry(stream, area, level, action));
304 if (action == ACCEPT)
305 updateRoutingCache(stream, area);
306 // This disables the initial fallback routing
307 detail::TargetRegistry::instance().routed();
310 prefix_ void senf::log::Target::unroute(detail::StreamBase const * stream,
311 detail::AreaBase const * area, unsigned level,
314 RIB::iterator i = std::find(rib_.begin(), rib_.end(),
315 RoutingEntry(stream, area, level, action));
317 unroute(std::distance(rib_.begin(), i));
320 prefix_ void senf::log::Target::updateRoutingCache(detail::StreamBase const * stream,
321 detail::AreaBase const * area)
324 StreamRegistry::Registry::iterator i (StreamRegistry::instance().registry_.begin());
325 StreamRegistry::Registry::iterator const i_end (StreamRegistry::instance().registry_.end());
326 for (; i != i_end ; ++i)
327 updateRoutingCache(i->second, area);
331 AreaRegistry::Registry::iterator i (AreaRegistry::instance().registry_.begin());
332 AreaRegistry::Registry::iterator const i_end (AreaRegistry::instance().registry_.end());
333 for (; i != i_end ; ++i)
334 updateRoutingCache(stream, i->second);
337 unsigned limit (DISABLED::value);
338 RIB::iterator i (rib_.begin());
339 RIB::iterator const i_end (rib_.end());
340 for(; i != i_end; ++i)
341 if ( (! i->stream_ || i->stream_ == stream) &&
342 (! i->area_ || i->area_ == area) &&
343 i->action_ == ACCEPT ) {
344 unsigned l (i->level_ == NONE::value ? stream->defaultRuntimeLimit() : i->level_);
348 if (limit == DISABLED::value)
349 area->removeRoutingCache(*this, *stream);
351 area->updateRoutingCache(*this, *stream, limit);
354 prefix_ void senf::log::Target::write(time_type timestamp,
355 detail::StreamBase const & stream,
356 detail::AreaBase const & area, unsigned level,
357 std::string const & message)
359 RIB::iterator i (rib_.begin());
360 RIB::iterator const i_end (rib_.end());
361 for (; i != i_end; ++i)
362 if ( (! i->stream_ || i->stream_ == &stream) &&
363 (! i->area_ || i->area_ == &area) &&
364 (i->level_ == NONE::value ? stream.defaultRuntimeLimit() : i->level_) <= level ) {
365 if (i->action_ == ACCEPT)
366 v_write(timestamp, stream.v_name(), area.v_name(), level, message);
372 std::string formatLabel(std::string const & l)
377 return l.substr(l.size()-29);
382 prefix_ void senf::log::Target::consoleList(std::ostream & os)
384 static char const * levels[] = {
385 "none", "verbose", "notice", "message", "important", "critical", "fatal", "disabled" };
387 boost::format fmt ("%2d %-29s %-29s %-9s %-6s\n");
388 os << fmt % "#" % "STREAM" % "AREA" % "LEVEL" % "ACTION";
390 for (iterator i (begin()); i != end(); ++i, ++n)
393 % formatLabel(i->stream())
394 % formatLabel(i->area())
396 % (i->action() == ACCEPT ? "accept" : "reject");
399 ///////////////////////////////////////////////////////////////////////////
400 // senf::log::detail::TargetRegistry
402 prefix_ void senf::log::detail::TargetRegistry::registerTarget(Target * target,
403 std::string const & name)
405 targets_.insert(target);
406 consoleDir_().add(name, target->consoleDir_());
409 prefix_ void senf::log::detail::TargetRegistry::write(StreamBase const & stream,
410 AreaBase const & area, unsigned level,
411 std::string const & msg)
413 if (fallbackRouting_) {
414 if (level >= stream.defaultRuntimeLimit())
415 static_cast<Target &>(ConsoleTarget::instance()).v_write(
416 TimeSource::now(), stream.v_name(), area.v_name(), level, msg );
419 area.write( TimeSource::now(), stream, level, msg );
421 ///////////////////////////////////////////////////////////////////////////
424 prefix_ std::ostream & senf::log::operator<<(std::ostream & os, senf::log::Target::action_t const & action)
426 if( action == Target::ACCEPT) os << "ACCEPT";
427 else if( action == Target::REJECT) os << "REJECT";
428 else os << "unknown action";
433 ///////////////////////////////cc.e////////////////////////////////////////
435 //#include "Target.mpp"
441 // comment-column: 40
442 // c-file-style: "senf"
443 // indent-tabs-mode: nil
444 // ispell-local-dictionary: "american"
445 // compile-command: "scons -u test"