Fawkes API  Fawkes Development Version
log.cpp
00001 
00002 /***************************************************************************
00003  *  log.cpp - XML-RPC methods related to logging
00004  *
00005  *  Created: Mon Aug 31 20:50:37 2009
00006  *  Copyright  2006-2009  Tim Niemueller [www.niemueller.de]
00007  *
00008  ****************************************************************************/
00009 
00010 /*  This program is free software; you can redistribute it and/or modify
00011  *  it under the terms of the GNU General Public License as published by
00012  *  the Free Software Foundation; either version 2 of the License, or
00013  *  (at your option) any later version.
00014  *
00015  *  This program is distributed in the hope that it will be useful,
00016  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00017  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00018  *  GNU Library General Public License for more details.
00019  *
00020  *  Read the full text in the LICENSE.GPL file in the doc directory.
00021  */
00022 
00023 #include "log.h"
00024 #include <logging/cache.h>
00025 
00026 #include <xmlrpc-c/girerr.hpp>
00027 
00028 using namespace fawkes;
00029 
00030 /** @class XmlRpcLogMethods "log.h"
00031  * Wrapper class for logging related XML-RPC methods.
00032  * @author Tim Niemueller
00033  */
00034 
00035 /** Constructor.
00036  * @param registry XML registry, methods will be automatically registered
00037  * @param cache_logger cache logger to access recent log messages
00038  * @param logger logger to output messages
00039  */
00040 XmlRpcLogMethods::XmlRpcLogMethods(xmlrpc_c::registry *registry,
00041                                    fawkes::CacheLogger *cache_logger,
00042                                    fawkes::Logger *logger)
00043 {
00044   __xmlrpc_registry = registry;
00045   __cache_logger    = cache_logger;
00046   __logger          = logger;
00047   __log_entries     = new log_entries(cache_logger);
00048   __log_get_size    = new log_get_size(cache_logger);
00049   __log_set_size    = new log_set_size(cache_logger);
00050   __log_log_debug   = new log_log(logger, fawkes::Logger::LL_DEBUG);
00051   __log_log_info    = new log_log(logger, fawkes::Logger::LL_INFO);
00052   __log_log_warn    = new log_log(logger, fawkes::Logger::LL_WARN);
00053   __log_log_error   = new log_log(logger, fawkes::Logger::LL_ERROR);
00054   __xmlrpc_registry->addMethod("log.entries",   __log_entries);
00055   __xmlrpc_registry->addMethod("log.get_size",  __log_get_size);
00056   __xmlrpc_registry->addMethod("log.set_size",  __log_set_size);
00057   __xmlrpc_registry->addMethod("log.log_debug", __log_log_debug);
00058   __xmlrpc_registry->addMethod("log.log_info",  __log_log_info);
00059   __xmlrpc_registry->addMethod("log.log_warn",  __log_log_warn);
00060   __xmlrpc_registry->addMethod("log.log_error", __log_log_error);
00061 }
00062 
00063 /** Destructor. */
00064 XmlRpcLogMethods::~XmlRpcLogMethods()
00065 {
00066   delete __log_entries;
00067   delete __log_get_size;
00068   delete __log_set_size;
00069   delete __log_log_debug;
00070   delete __log_log_info;
00071   delete __log_log_warn;
00072   delete __log_log_debug;
00073 }
00074 
00075 
00076 /** @class XmlRpcLogMethods::log_entries "log.h"
00077  * Get most recent log entries via XML-RPC method.
00078  * @author Tim Niemueller
00079  */
00080 
00081 /** Constructor.
00082  * @param cache_logger cache logger to access recent log messages
00083  */
00084 XmlRpcLogMethods::log_entries::log_entries(fawkes::CacheLogger *cache_logger)
00085 {
00086   _signature = "A:";
00087   _help = "Returns array of recent log messages. Each entry is a struct "
00088     "consisting of the entries component, time string and message.";
00089 
00090   __cache_logger = cache_logger;
00091 }
00092 
00093 /** Virtual empty destructor. */
00094 XmlRpcLogMethods::log_entries::~log_entries()
00095 {
00096 }
00097 
00098 /** Execute method.
00099  * @param params parameters
00100  * @param result result value
00101  */
00102 void
00103 XmlRpcLogMethods::log_entries::execute(xmlrpc_c::paramList const& params,
00104                                        xmlrpc_c::value *   const  result)
00105 {
00106   // No reference, copy!
00107   __cache_logger->lock();
00108   std::list<CacheLogger::CacheEntry> messages = __cache_logger->get_messages();
00109   __cache_logger->unlock();
00110   std::list<CacheLogger::CacheEntry>::iterator i;
00111 
00112   std::vector<xmlrpc_c::value> array;
00113 
00114   for (i = messages.begin(); i != messages.end(); ++i) {
00115     std::map<std::string, xmlrpc_c::value> elem;
00116     elem.insert(std::make_pair("component", xmlrpc_c::value_string(i->component)));
00117     elem.insert(std::make_pair("time", xmlrpc_c::value_datetime(i->time)));
00118     elem.insert(std::make_pair("message", xmlrpc_c::value_string(i->message)));
00119     array.push_back(xmlrpc_c::value_struct(elem));
00120   }
00121 
00122   *result = xmlrpc_c::value_array(array);
00123 }
00124 
00125 
00126 /** @class XmlRpcLogMethods::log_get_size "log.h"
00127  * XML-RPC method to get the current cache log size.
00128  * @author Tim Niemueller
00129  */
00130 
00131 
00132 /** Constructor.
00133  * @param cache_logger cache logger to access recent log messages
00134  */
00135 XmlRpcLogMethods::log_get_size::log_get_size(fawkes::CacheLogger *cache_logger)
00136 {
00137   _signature = "i:";
00138   _help = "Get current maximum size of the cache log.";
00139 
00140   __cache_logger = cache_logger;
00141 }
00142 
00143 /** Virtual empty destructor. */
00144 XmlRpcLogMethods::log_get_size::~log_get_size()
00145 {
00146 }
00147 
00148 /** Execute method.
00149  * @param params parameters
00150  * @param result result value
00151  */
00152 void
00153 XmlRpcLogMethods::log_get_size::execute(xmlrpc_c::paramList const& params,
00154                                         xmlrpc_c::value *   const  result)
00155 {
00156   *result = xmlrpc_c::value_int(__cache_logger->size());
00157 }
00158 
00159 
00160 
00161 /** @class XmlRpcLogMethods::log_set_size "log.h"
00162  * XML-RPC method to set maximum size of cache logger.
00163  * @author Tim Niemueller
00164  */
00165 
00166 /** Constructor.
00167  * @param cache_logger cache logger
00168  */
00169 XmlRpcLogMethods::log_set_size::log_set_size(fawkes::CacheLogger *cache_logger)
00170 {
00171   _signature = "n:i";
00172   _help = "Set maximum size of cache logger.";
00173 
00174   __cache_logger = cache_logger;
00175 }
00176 
00177 /** Virtual empty destructor. */
00178 XmlRpcLogMethods::log_set_size::~log_set_size()
00179 {
00180 }
00181 
00182 /** Execute method.
00183  * @param params parameters
00184  * @param result result value
00185  */
00186 void
00187 XmlRpcLogMethods::log_set_size::execute(xmlrpc_c::paramList const& params,
00188                                         xmlrpc_c::value *   const  result)
00189 {
00190   int new_size = params.getInt(0);
00191   if (new_size <= 0) {
00192     throw xmlrpc_c::fault("Illegal size value, must be integer > 0",
00193                           xmlrpc_c::fault::CODE_UNSPECIFIED);
00194   }
00195   __cache_logger->set_size(new_size);
00196   *result = xmlrpc_c::value_nil();
00197 }
00198 
00199 
00200 
00201 /** @class XmlRpcLogMethods::log_log "log.h"
00202  * XML-RPC method to log a message.
00203  * @author Tim Niemueller
00204  */
00205 
00206 /** Constructor.
00207  * @param logger logger to output messages
00208  * @param log_level level to log messages at
00209  */
00210 XmlRpcLogMethods::log_log::log_log(fawkes::Logger *logger,
00211                                    fawkes::Logger::LogLevel log_level)
00212 {
00213   _signature = "n:ss";
00214   _help = "Log message of specified level, arguments are component and message.";
00215 
00216   __logger    = logger;
00217   __log_level = log_level;
00218 }
00219 
00220 /** Virtual empty destructor. */
00221 XmlRpcLogMethods::log_log::~log_log()
00222 {
00223 }
00224 
00225 /** Execute method.
00226  * @param params parameters
00227  * @param result result value
00228  */
00229 void
00230 XmlRpcLogMethods::log_log::execute(xmlrpc_c::paramList const& params,
00231                                         xmlrpc_c::value *   const  result)
00232 {
00233   std::string component = params.getString(0);
00234   std::string message   = params.getString(1);
00235   __logger->log(__log_level, component.c_str(), "%s", message.c_str());
00236   *result = xmlrpc_c::value_nil();
00237 }