Utils/Logger/Target.cc

   1 // $Id$
   2 //
   3 // Copyright (C) 2007
   4 // Fraunhofer Institute for Open Communication Systems (FOKUS)
   5 // Competence Center NETwork research (NET), St. Augustin, GERMANY
   6 //     Stefan Bund <g0dil@berlios.de>
   7 //
   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.
  12 //
  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.
  17 //
  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.
  22
  23 /** \file
  24     \brief Target non-inline non-template implementation */
  25
  26 #include "Target.hh"
  27 #include "Target.ih"
  28
  29 // Custom includes
  30 #include <algorithm>
  31 #include <boost/format.hpp>
  32 #include "ConsoleTarget.hh"
  33 #include "../Console/Console.hh"
  34 #include "../Console/Sysdir.hh"
  35 #include "../membind.hh"
  36
  37 //#include "Target.mpp"
  38 #define prefix_
  39 ///////////////////////////////cc.p////////////////////////////////////////
  40
  41 ///////////////////////////////////////////////////////////////////////////
  42 // senf::log::Target
  43
  44 namespace senf {
  45 namespace log {
  46
  47     SENF_CONSOLE_REGISTER_ENUM_MEMBER( Target, action_t, (ACCEPT)(REJECT) );
  48
  49 namespace detail {
  50
  51     SENF_CONSOLE_REGISTER_ENUM_MEMBER( TargetRegistry, Level,
  52                                        (VERBOSE)(NOTICE)(MESSAGE)(IMPORTANT)(CRITICAL)(FATAL) );
  53
  54 }}}
  55
  56 prefix_ senf::log::Target::Target(std::string const & name)
  57 {
  58     namespace kw = senf::console::kw;
  59
  60     detail::TargetRegistry::instance().registerTarget(this, name);
  61     consoleDir_().add("list", senf::membind(&Target::consoleList, this))
  62         .doc("Show routing table\n"
  63              "\n"
  64              "Columns:\n"
  65              "    #       rule index\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"
  69              "            are:\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)>(
  75                                                 senf::membind(
  76                                                     static_cast<void (Target::*)(
  77                                                         std::string const &, std::string const &,
  78                                                         unsigned, action_t, int)>(&Target::route),
  79                                                     this)))
  80         .arg("stream",
  81              "stream to match or empty to match any stream\n"
  82              "              use '/sys/log/streams' to list all available streams",
  83              kw::default_value="")
  84         .arg("area",
  85              "area to match or empty to match any area\n"
  86              "              use '/sys/log/areas' to list all available areas",
  87              kw::default_value="")
  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",
  93              kw::default_value=-1)
  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"
  97              "\n"
  98              "Examples:\n"
  99              "\n"
 100              "    route\n"
 101              "        route all messages to this target.\n"
 102              "\n"
 103              "    route \"\" my::Class\n"
 104              "        route all messages which are in the my::Class area.\n"
 105              "\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"
 109              "\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)>(
 120                                                 senf::membind(
 121                                                     static_cast<void (Target::*)(
 122                                                         std::string const &, std::string const &,
 123                                                         unsigned, action_t)>(&Target::unroute),
 124                                                     this)))
 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.");
 137 }
 138
 139 prefix_ senf::log::Target::~Target()
 140 {
 141     while( ! rib_.empty()) {
 142         // This is slow but simplifies the area cache handling and removing a target should be
 143         // relatively seldom
 144         RIB::reverse_iterator i (rib_.rbegin());
 145         unroute(i->stream_, i->area_, i->level_, i->action_);
 146     }
 147     detail::TargetRegistry::instance().unregisterTarget(this);
 148 }
 149
 150 prefix_ void senf::log::Target::route(std::string const & stream, std::string const & area,
 151                                       unsigned level, action_t action, int index)
 152 {
 153     detail::StreamBase const * s (0);
 154     if (! stream.empty()) {
 155         s = StreamRegistry::instance().lookup(stream);
 156         if (!s)
 157             throw InvalidStreamException();
 158     }
 159     detail::AreaBase const * a (0);
 160     if (! area.empty()) {
 161         a = AreaRegistry::instance().lookup(area);
 162         if (!a)
 163             throw InvalidAreaException();
 164     }
 165     route(s, a, level, action, index);
 166 }
 167
 168 prefix_ void senf::log::Target::unroute(std::string const & stream, std::string const & area,
 169                                         unsigned level, action_t action)
 170 {
 171     detail::StreamBase const * s (0);
 172     if (! stream.empty()) {
 173         s = StreamRegistry::instance().lookup(stream);
 174         if (!s)
 175             throw InvalidStreamException();
 176     }
 177     detail::AreaBase const * a (0);
 178     if (! area.empty()) {
 179         a = AreaRegistry::instance().lookup(area);
 180         if (!a)
 181             throw InvalidAreaException();
 182     }
 183     unroute(s, a, level, action);
 184 }
 185
 186 prefix_ void senf::log::Target::unroute(int index)
 187 {
 188     if (rib_.empty())
 189         return;
 190     RIB::iterator i;
 191     if (index < 0) {
 192         if (RIB::size_type(-index) >= rib_.size())
 193             i = rib_.begin();
 194         else {
 195             i = rib_.end();
 196             std::advance(i, index);
 197         }
 198     } else {
 199         if (RIB::size_type(index+1) >= rib_.size()) {
 200             i = rib_.end();
 201             --i;
 202         } else {
 203             i = rib_.begin();
 204             std::advance(i, index);
 205         }
 206     }
 207     if (i == rib_.end())
 208         return;
 209     RoutingEntry entry (*i);
 210     rib_.erase(i);
 211     if (entry.action_ == ACCEPT)
 212         updateRoutingCache(entry.stream_, entry.area_);
 213 }
 214
 215 prefix_ void senf::log::Target::flush()
 216 {
 217     RIB old;
 218     rib_.swap(old);
 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_);
 224 }
 225
 226 ////////////////////////////////////////
 227 // protected members
 228
 229 prefix_ senf::log::detail::TargetRegistry::TargetRegistry()
 230     : fallbackRouting_(true)
 231 {
 232     namespace kw = senf::console::kw;
 233
 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");
 248 }
 249
 250 prefix_ void senf::log::detail::TargetRegistry::consoleAreas(std::ostream & os)
 251 {
 252     AreaRegistry::iterator i (AreaRegistry::instance().begin());
 253     AreaRegistry::iterator const i_end (AreaRegistry::instance().end());
 254     for (; i != i_end; ++i)
 255         os << *i << "\n";
 256 }
 257
 258 prefix_ void senf::log::detail::TargetRegistry::consoleStreams(std::ostream & os)
 259 {
 260     StreamRegistry::iterator i (StreamRegistry::instance().begin());
 261     StreamRegistry::iterator const i_end (StreamRegistry::instance().end());
 262     for (; i != i_end; ++i)
 263         os << *i << "\n";
 264 }
 265
 266 prefix_ void senf::log::detail::TargetRegistry::consoleWrite(std::string const & stream,
 267                                                              std::string const & area,
 268                                                              Level level,
 269                                                              std::string const & msg)
 270 {
 271     detail::StreamBase const * s (StreamRegistry::instance().lookup(stream));
 272     if (!s)
 273         throw Target::InvalidStreamException();
 274     detail::AreaBase const * a (AreaRegistry::instance().lookup(area));
 275     if (!a)
 276         throw Target::InvalidAreaException();
 277     write(*s, *a, level, msg);
 278 }
 279
 280 prefix_ senf::console::ScopedDirectory<> & senf::log::Target::consoleDir()
 281 {
 282     return consoleDir_();
 283 }
 284
 285 ////////////////////////////////////////
 286 // private members
 287
 288 prefix_ void senf::log::Target::route(detail::StreamBase const * stream,
 289                                       detail::AreaBase const * area, unsigned level,
 290                                       action_t action, int index)
 291 {
 292     RIB::iterator i;
 293     if (index < 0) {
 294         if (RIB::size_type(-index-1) >= rib_.size())
 295             i = rib_.begin();
 296         else {
 297             i = rib_.end();
 298             std::advance(i, index + 1 );
 299         }
 300     } else {
 301         if (RIB::size_type(index) >= rib_.size())
 302             i = rib_.end();
 303         else {
 304             i = rib_.begin();
 305             std::advance(i, index);
 306         }
 307     }
 308     rib_.insert(i, RoutingEntry(stream, area, level, action));
 309     if (action == ACCEPT)
 310         updateRoutingCache(stream, area);
 311     // This disables the initial fallback routing
 312     detail::TargetRegistry::instance().routed();
 313 }
 314
 315 prefix_ void senf::log::Target::unroute(detail::StreamBase const * stream,
 316                                         detail::AreaBase const * area, unsigned level,
 317                                         action_t action)
 318 {
 319     RIB::iterator i = std::find(rib_.begin(), rib_.end(),
 320                                 RoutingEntry(stream, area, level, action));
 321     if (i != rib_.end())
 322         unroute(std::distance(rib_.begin(), i));
 323 }
 324
 325 prefix_ void senf::log::Target::updateRoutingCache(detail::StreamBase const * stream,
 326                                                    detail::AreaBase const * area)
 327 {
 328     if (! stream) {
 329         StreamRegistry::Registry::iterator i (StreamRegistry::instance().registry_.begin());
 330         StreamRegistry::Registry::iterator const i_end (StreamRegistry::instance().registry_.end());
 331         for (; i != i_end ; ++i)
 332             updateRoutingCache(i->second, area);
 333         return;
 334     }
 335     if (! area) {
 336         AreaRegistry::Registry::iterator i (AreaRegistry::instance().registry_.begin());
 337         AreaRegistry::Registry::iterator const i_end (AreaRegistry::instance().registry_.end());
 338         for (; i != i_end ; ++i)
 339             updateRoutingCache(stream, i->second);
 340         return;
 341     }
 342     unsigned limit (DISABLED::value);
 343     RIB::iterator i (rib_.begin());
 344     RIB::iterator const i_end (rib_.end());
 345     for(; i != i_end; ++i)
 346         if ( (! i->stream_ || i->stream_ == stream) &&
 347              (! i->area_ || i->area_ == area) &&
 348              i->action_ == ACCEPT ) {
 349             unsigned l (i->level_ == NONE::value ? stream->defaultRuntimeLimit() : i->level_);
 350             if (l < limit)
 351                 limit = l;
 352         }
 353     if (limit == DISABLED::value)
 354         area->removeRoutingCache(*this, *stream);
 355     else
 356         area->updateRoutingCache(*this, *stream, limit);
 357 }
 358
 359 prefix_ void senf::log::Target::write(time_type timestamp,
 360                                       detail::StreamBase const & stream,
 361                                       detail::AreaBase const & area, unsigned level,
 362                                       std::string const & message)
 363 {
 364     RIB::iterator i (rib_.begin());
 365     RIB::iterator const i_end (rib_.end());
 366     for (; i != i_end; ++i)
 367         if ( (! i->stream_ || i->stream_ == &stream) &&
 368              (! i->area_ || i->area_ == &area) &&
 369              (i->level_ == NONE::value ? stream.defaultRuntimeLimit() : i->level_) <= level ) {
 370             if (i->action_ == ACCEPT)
 371                 v_write(timestamp, stream.v_name(), area.v_name(), level, message);
 372             return;
 373         }
 374 }
 375
 376 namespace {
 377     std::string formatLabel(std::string const & l)
 378     {
 379         if (l.empty())
 380             return "-";
 381         if (l.size() > 29)
 382             return l.substr(l.size()-29);
 383         return l;
 384     }
 385 }
 386
 387 prefix_ void senf::log::Target::consoleList(std::ostream & os)
 388 {
 389     static char const * levels[] = {
 390         "none", "verbose", "notice", "message", "important", "critical", "fatal", "disabled" };
 391
 392     boost::format fmt ("%2d %-29s %-29s %-9s %-6s\n");
 393     os << fmt % "#" % "STREAM" % "AREA" % "LEVEL" % "ACTION";
 394     unsigned n (0);
 395     for (iterator i (begin()); i != end(); ++i, ++n)
 396         os << fmt
 397             % n
 398             % formatLabel(i->stream())
 399             % formatLabel(i->area())
 400             % levels[i->level()]
 401             % (i->action() == ACCEPT ? "accept" : "reject");
 402 }
 403
 404 ///////////////////////////////////////////////////////////////////////////
 405 // senf::log::detail::TargetRegistry
 406
 407 prefix_ void senf::log::detail::TargetRegistry::registerTarget(Target * target,
 408                                                                std::string const & name)
 409 {
 410     targets_.insert(target);
 411     consoleDir_().add(name, target->consoleDir_());
 412 }
 413
 414 prefix_ void senf::log::detail::TargetRegistry::write(StreamBase const & stream,
 415                                                       AreaBase const & area, unsigned level,
 416                                                       std::string const & msg)
 417 {
 418     if (fallbackRouting_) {
 419         if (level >= stream.defaultRuntimeLimit())
 420             static_cast<Target &>(ConsoleTarget::instance()).v_write(
 421                 TimeSource::now(), stream.v_name(), area.v_name(), level, msg );
 422     }
 423     else
 424         area.write( TimeSource::now(), stream, level, msg );
 425 }
 426 ///////////////////////////////////////////////////////////////////////////
 427 // namespace members
 428
 429 prefix_ std::ostream & senf::log::operator<<(std::ostream & os, senf::log::Target::action_t const & action)
 430 {
 431     if( action == Target::ACCEPT) os << "ACCEPT";
 432     else if( action == Target::REJECT) os << "REJECT";
 433     else os << "unknown action";
 434     return os;
 435 }
 436
 437
 438 ///////////////////////////////cc.e////////////////////////////////////////
 439 #undef prefix_
 440 //#include "Target.mpp"
 441
 442
 443 // Local Variables:
 444 // mode: c++
 445 // fill-column: 100
 446 // comment-column: 40
 447 // c-file-style: "senf"
 448 // indent-tabs-mode: nil
 449 // ispell-local-dictionary: "american"
 450 // compile-command: "scons -u test"
 451 // End: