Fawkes API
Fawkes Development Version
|
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 <utils/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 }