Fawkes API Fawkes Development Version

net_handler.cpp

00001 
00002 /***************************************************************************
00003  *  net_handler.cpp - Fawkes configuration network handler
00004  *
00005  *  Generated: Sat Jan 06 22:55:03 2007
00006  *  Copyright  2006-2007  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. A runtime exception applies to
00014  *  this software (see LICENSE.GPL_WRE file mentioned below for details).
00015  *
00016  *  This program is distributed in the hope that it will be useful,
00017  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00018  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00019  *  GNU Library General Public License for more details.
00020  *
00021  *  Read the full text in the LICENSE.GPL_WRE file in the doc directory.
00022  */
00023 
00024 #include <config/net_handler.h>
00025 #include <config/net_messages.h>
00026 #include <config/net_list_content.h>
00027 #include <utils/logging/liblogger.h>
00028 
00029 #include <netcomm/fawkes/component_ids.h>
00030 #include <netcomm/fawkes/hub.h>
00031 #include <config/config.h>
00032 
00033 #include <algorithm>
00034 #include <cstring>
00035 
00036 namespace fawkes {
00037 
00038 /** @class ConfigNetworkHandler <config/net_handler.h>
00039  * Fawkes Configuration Network Handler.
00040  * It provides access to a given config via the network.
00041  * This is mainly used to allow modification of config values over the network.
00042  *
00043  * @author Tim Niemueller
00044  */
00045 
00046 /** Constructor.
00047  * @param config configuration, loaded and ready to be used for getting and
00048  * setting values
00049  * @param hub Fawkes network hub to use for receiving and sending network
00050  * messages
00051  */
00052 ConfigNetworkHandler::ConfigNetworkHandler(Configuration *config,
00053                                          FawkesNetworkHub *hub)
00054   : Thread("ConfigNetworkHandler", Thread::OPMODE_WAITFORWAKEUP),
00055     FawkesNetworkHandler(FAWKES_CID_CONFIGMANAGER),
00056     ConfigurationChangeHandler()
00057 {
00058   __config = config;
00059   __hub    = hub;
00060 
00061   start();
00062 
00063   __config->add_change_handler(this);
00064   __hub->add_handler( this );
00065 }
00066 
00067 
00068 /** Destructor. */
00069 ConfigNetworkHandler::~ConfigNetworkHandler()
00070 {
00071   cancel();
00072   join();
00073   __config->rem_change_handler(this);
00074   __inbound_queue.clear();
00075 }
00076 
00077 
00078 /** Send invalid value message.
00079  * @param clid client ID
00080  * @param path path
00081  */
00082 void
00083 ConfigNetworkHandler::send_inv_value(unsigned int clid, const char *path)
00084 {
00085   config_invval_msg_t *r = prepare_msg<config_invval_msg_t>(path, false);
00086   __hub->send(clid, FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_INV_VALUE, r, sizeof(config_invval_msg_t));
00087 }
00088 
00089 
00090 /** Send value.
00091  * @param clid client ID
00092  * @param i value
00093  */
00094 void
00095 ConfigNetworkHandler::send_value(unsigned int clid, Configuration::ValueIterator *i)
00096 {
00097   if ( i->is_float() ) {
00098     try {
00099       config_float_value_msg_t *r = prepare_msg<config_float_value_msg_t>(i->path(), i->is_default());
00100       r->f = i->get_float();
00101       __hub->send(clid, FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_FLOAT_VALUE, r, sizeof(config_float_value_msg_t));
00102     } catch (Exception &e) {
00103       LibLogger::log_warn("ConfigNetworkHandler",
00104                           "send_value: Value %s could not be sent",
00105                           i->path());
00106       LibLogger::log_warn("ConfigNetworkHandler", e);
00107     }
00108   } else if ( i->is_uint() ) {
00109     try {
00110       config_uint_value_msg_t *r = prepare_msg<config_uint_value_msg_t>(i->path(), i->is_default());
00111       r->u = i->get_uint();
00112       __hub->send(clid, FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_UINT_VALUE, r, sizeof(config_uint_value_msg_t));
00113     } catch (Exception &e) {
00114       LibLogger::log_warn("ConfigNetworkHandler",
00115                           "send_value: Value %s could not be sent",
00116                           i->path());
00117       LibLogger::log_warn("ConfigNetworkHandler", e);
00118     }
00119   } else if ( i->is_int() ) {
00120     try {
00121       config_int_value_msg_t *r = prepare_msg<config_int_value_msg_t>(i->path(), i->is_default());
00122       r->i = i->get_int();
00123       __hub->send(clid, FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_INT_VALUE, r, sizeof(config_int_value_msg_t));
00124     } catch (Exception &e) {
00125       LibLogger::log_warn("ConfigNetworkHandler",
00126                           "send_value: Value %s could not be sent",
00127                           i->path());
00128       LibLogger::log_warn("ConfigNetworkHandler", e);
00129     }
00130   } else if ( i->is_bool() ) {
00131     try {
00132       config_bool_value_msg_t *r = prepare_msg<config_bool_value_msg_t>(i->path(), i->is_default());
00133       r->b = (i->get_bool() ? 1 : 0);
00134       __hub->send(clid, FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_BOOL_VALUE, r, sizeof(config_bool_value_msg_t));
00135     } catch (Exception &e) {
00136       LibLogger::log_warn("ConfigNetworkHandler",
00137                           "send_value: Value %s could not be sent",
00138                           i->path());
00139       LibLogger::log_warn("ConfigNetworkHandler", e);
00140     }
00141   } else if ( i->is_string() ) {
00142     try {
00143       size_t sl = sizeof(config_string_value_msg_t) + i->get_string().length();
00144       config_string_value_msg_t *m = (config_string_value_msg_t *)calloc(1, sl);
00145       strncpy(m->cp.path, i->path(), CONFIG_MSG_PATH_LENGTH);
00146       m->cp.is_default = i->is_default() ? 1 : 0;
00147       m->s_length = i->get_string().length();
00148       strcpy(m->s, i->get_string().c_str());
00149       __hub->send(clid, FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_STRING_VALUE, m, sl);
00150     } catch (Exception &e) {
00151       LibLogger::log_warn("ConfigNetworkHandler",
00152                           "send_value: Value %s could not be sent",
00153                           i->path());
00154       LibLogger::log_warn("ConfigNetworkHandler", e);
00155     }
00156   }
00157 }
00158 
00159 
00160 /** Process all network messages that have been received. */
00161 void
00162 ConfigNetworkHandler::loop()
00163 {
00164   while ( ! __inbound_queue.empty() ) {
00165     FawkesNetworkMessage *msg = __inbound_queue.front();
00166 
00167     // printf("Received message of type %u\n", msg->msgid());
00168 
00169     if (msg->msgid() == MSG_CONFIG_SUBSCRIBE) {
00170 
00171       __subscribers.push_back_locked(msg->clid());
00172       __subscribers.sort();
00173       __subscribers.unique();
00174 
00175       __config->lock();
00176       ConfigListContent *content = new ConfigListContent();
00177       Configuration::ValueIterator *i = __config->iterator_default();
00178       while ( i->next() ) {
00179         content->append(i);
00180       }
00181       delete i;
00182       i = __config->iterator_hostspecific();
00183       while ( i->next() ) {
00184         content->append(i);
00185       }
00186       delete i;
00187       __hub->send(msg->clid(), FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_LIST, content);
00188       __config->unlock();
00189 
00190     } else if (msg->msgid() == MSG_CONFIG_ERASE_VALUE) {
00191       try {
00192         config_erase_value_msg_t *m = msg->msg<config_erase_value_msg_t>();
00193         char path[CONFIG_MSG_PATH_LENGTH + 1];
00194         path[CONFIG_MSG_PATH_LENGTH] = 0;
00195         strncpy(path, m->cp.path, CONFIG_MSG_PATH_LENGTH);
00196 
00197         if ( m->cp.is_default == 1 ) {
00198           __config->erase_default(path);
00199         } else {
00200           __config->erase(path);
00201         }
00202 
00203         config_value_erased_msg_t *r = prepare_msg<config_value_erased_msg_t>(path, (m->cp.is_default == 1));
00204         __hub->send(msg->clid(), FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_VALUE_ERASED,
00205                     r, sizeof(config_value_erased_msg_t));
00206 
00207       } catch (Exception &e) {
00208         send_inv_value(msg->clid(), "?");
00209         e.append("Failed to erase value");
00210         LibLogger::log_warn("ConfigNetworkHandler", "Failed to erase value");
00211         LibLogger::log_warn("ConfigNetworkHandler", e);
00212       }
00213 
00214     } else if ( (msg->msgid() >= MSG_CONFIG_GET_BEGIN) &&
00215          (msg->msgid() <= MSG_CONFIG_GET_END) ) {
00216 
00217       if ( msg->payload_size() != sizeof(config_getval_msg_t) ) {
00218         LibLogger::log_warn("ConfigNetworkHandler",
00219                             "CONFIG_GET_FLOAT: invalid payload size "
00220                             "(received %zu instead of %zu bytes",
00221                             msg->payload_size(), sizeof(config_getval_msg_t));
00222       } else {
00223         config_getval_msg_t *m = (config_getval_msg_t *)msg->payload();
00224         char path[CONFIG_MSG_PATH_LENGTH + 1];
00225         path[CONFIG_MSG_PATH_LENGTH] = 0;
00226         strncpy(path, m->cp.path, CONFIG_MSG_PATH_LENGTH);
00227 
00228         switch (msg->msgid()) {
00229         case MSG_CONFIG_GET_FLOAT:
00230           try {
00231             float f = __config->get_float(path);
00232             bool  d = __config->is_default(path);
00233             config_float_value_msg_t *r = prepare_msg<config_float_value_msg_t>(path, d);
00234             r->f = f;
00235             __hub->send(msg->clid(), FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_FLOAT_VALUE,
00236                       r, sizeof(config_float_value_msg_t));
00237           } catch (Exception &e) {
00238             send_inv_value(msg->clid(), path);
00239             LibLogger::log_warn("ConfigNetworkHandler",
00240                                 "get float: Value %s could not be found", path);
00241             LibLogger::log_warn("ConfigNetworkHandler", e);
00242           }
00243           break;
00244 
00245         case MSG_CONFIG_GET_UINT:
00246           try {
00247             unsigned int u = __config->get_uint(path);
00248             bool  d = __config->is_default(path);
00249             config_uint_value_msg_t *r = prepare_msg<config_uint_value_msg_t>(path, d);
00250             r->u = u;
00251             __hub->send(msg->clid(), FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_UINT_VALUE,
00252                       r, sizeof(config_uint_value_msg_t));
00253           } catch (Exception &e) {
00254             send_inv_value(msg->clid(), path);
00255             LibLogger::log_warn("ConfigNetworkHandler",
00256                                 "get uint: Value %s could not be found", path);
00257             LibLogger::log_warn("ConfigNetworkHandler", e);
00258           }
00259           break;
00260 
00261         case MSG_CONFIG_GET_INT:
00262           try {
00263             int i = __config->get_int(path);
00264             bool  d = __config->is_default(path);
00265             config_int_value_msg_t *r = prepare_msg<config_int_value_msg_t>(path, d);
00266             r->i = i;
00267             __hub->send(msg->clid(), FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_INT_VALUE,
00268                       r, sizeof(config_int_value_msg_t));
00269           } catch (Exception &e) {
00270             send_inv_value(msg->clid(), path);
00271             LibLogger::log_warn("ConfigNetworkHandler",
00272                                 "get int: Value %s could not be found", path);
00273             LibLogger::log_warn("ConfigNetworkHandler", e);
00274           }
00275           break;
00276 
00277         case MSG_CONFIG_GET_BOOL:
00278           try {
00279             bool b = __config->get_bool(path);
00280             bool d = __config->is_default(path);
00281             config_bool_value_msg_t *r = prepare_msg<config_bool_value_msg_t>(path, d);
00282             r->b = b;
00283             __hub->send(msg->clid(), FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_BOOL_VALUE,
00284                       r, sizeof(config_bool_value_msg_t));
00285           } catch (Exception &e) {
00286             send_inv_value(msg->clid(), path);
00287             LibLogger::log_warn("ConfigNetworkHandler",
00288                                 "get bool: Value %s could not be found", path);
00289             LibLogger::log_warn("ConfigNetworkHandler", e);
00290           }
00291           break;
00292 
00293         case MSG_CONFIG_GET_STRING:
00294           try {
00295             std::string s = __config->get_string(path);
00296             bool  d = __config->is_default(path);
00297             config_string_value_msg_t *r = prepare_string_msg<config_string_value_msg_t>(path, d, s.length());
00298             strcpy(r->s, s.c_str());
00299             __hub->send(msg->clid(), FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_STRING_VALUE,
00300                       r, sizeof(config_string_value_msg_t));
00301           } catch (Exception &e) {
00302             send_inv_value(msg->clid(), path);
00303             LibLogger::log_warn("ConfigNetworkHandler",
00304                                 "get string: Value %s could not be found", path);
00305             LibLogger::log_warn("ConfigNetworkHandler", e);
00306           }
00307           break;
00308 
00309         case MSG_CONFIG_GET_VALUE:
00310           try {
00311             Configuration::ValueIterator *i = __config->get_value(path);
00312             if ( i->next() ) {
00313               send_value(msg->clid(), i);
00314             } else {
00315               send_inv_value(msg->clid(), path);
00316             }
00317             delete i;
00318           } catch (ConfigurationException &e) {
00319             LibLogger::log_warn("ConfigNetworkHandler",
00320                                 "get value: Value %s could not be found", path);
00321             LibLogger::log_warn("ConfigNetworkHandler", e);
00322           }
00323           break;
00324 
00325         }
00326       }
00327     } else if ( (msg->msgid() >= MSG_CONFIG_SET_BEGIN) &&
00328                 (msg->msgid() <= MSG_CONFIG_SET_END) ) {
00329       
00330       char path[CONFIG_MSG_PATH_LENGTH + 1];
00331       if ( msg->payload_size() < sizeof(config_descriptor_t)) {
00332         LibLogger::log_warn("ConfigNetworkHandler",
00333                             "inbound set: payload is too small"
00334                             "(%zu is less than %zu bytes",
00335                             msg->payload_size(), sizeof(config_descriptor_t));
00336         send_inv_value(msg->clid(), "?");
00337       } else {
00338         config_descriptor_t *d = (config_descriptor_t *)msg->payload();
00339         path[CONFIG_MSG_PATH_LENGTH] = 0;
00340         strncpy(path, d->path, CONFIG_MSG_PATH_LENGTH);
00341 
00342         switch (msg->msgid()) {
00343         case MSG_CONFIG_SET_FLOAT:
00344         case MSG_CONFIG_SET_DEFAULT_FLOAT:
00345           try {
00346             config_float_value_msg_t *m = msg->msg<config_float_value_msg_t>();
00347             if ( msg->msgid() == MSG_CONFIG_SET_FLOAT ) {
00348               __config->set_float(path, m->f);
00349             } else {
00350               __config->set_default_float(path, m->f);
00351             }
00352             float f = __config->get_float(path);
00353             config_float_value_msg_t *r = prepare_msg<config_float_value_msg_t>(path, (msg->msgid() == MSG_CONFIG_SET_DEFAULT_FLOAT));
00354             r->f = f;
00355             __hub->send(msg->clid(), FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_FLOAT_VALUE,
00356                       r, sizeof(config_float_value_msg_t));
00357           } catch (Exception &e) {
00358             send_inv_value(msg->clid(), path);
00359             LibLogger::log_warn("ConfigNetworkHandler",
00360                                 "set float: Value %s could not be set", path);
00361             LibLogger::log_warn("ConfigNetworkHandler", e);
00362           }
00363           break;
00364         
00365         case MSG_CONFIG_SET_UINT:
00366         case MSG_CONFIG_SET_DEFAULT_UINT:
00367           try {
00368             config_uint_value_msg_t *m = msg->msg<config_uint_value_msg_t>();
00369             if ( msg->msgid() == MSG_CONFIG_SET_UINT ) {
00370               __config->set_uint(path, m->u);
00371             } else {
00372               __config->set_default_uint(path, m->u);
00373             }
00374             unsigned int u = __config->get_uint(path);
00375             config_uint_value_msg_t *r = prepare_msg<config_uint_value_msg_t>(path, (msg->msgid() == MSG_CONFIG_SET_DEFAULT_UINT));
00376             r->u = u;
00377             __hub->send(msg->clid(), FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_UINT_VALUE,
00378                       r, sizeof(config_uint_value_msg_t));
00379           } catch (Exception &e) {
00380             send_inv_value(msg->clid(), path);
00381             LibLogger::log_warn("ConfigNetworkHandler",
00382                                 "set uint: Value %s could not be set", path);
00383             LibLogger::log_warn("ConfigNetworkHandler", e);
00384           }
00385           break;
00386         
00387         case MSG_CONFIG_SET_INT:
00388         case MSG_CONFIG_SET_DEFAULT_INT:
00389           try {
00390             config_int_value_msg_t *m = msg->msg<config_int_value_msg_t>();
00391             if ( msg->msgid() == MSG_CONFIG_SET_INT ) {
00392               __config->set_int(path, m->i);
00393             } else {
00394               __config->set_default_int(path, m->i);
00395             }
00396             int i = __config->get_int(path);
00397             config_int_value_msg_t *r = prepare_msg<config_int_value_msg_t>(path, (msg->msgid() == MSG_CONFIG_SET_DEFAULT_INT));
00398             r->i = i;
00399             __hub->send(msg->clid(), FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_INT_VALUE,
00400                       r, sizeof(config_int_value_msg_t));
00401           } catch (Exception &e) {
00402             send_inv_value(msg->clid(), path);
00403             LibLogger::log_warn("ConfigNetworkHandler",
00404                                 "set int: Value %s could not be set", path);
00405             LibLogger::log_warn("ConfigNetworkHandler", e);
00406           }
00407           break;
00408         
00409         case MSG_CONFIG_SET_BOOL:
00410         case MSG_CONFIG_SET_DEFAULT_BOOL:
00411           try {
00412             config_bool_value_msg_t *m = msg->msg<config_bool_value_msg_t>();
00413             if ( msg->msgid() == MSG_CONFIG_SET_BOOL ) {
00414               __config->set_bool(path, (m->b != 0));
00415             } else {
00416               __config->set_default_bool(path, (m->b != 0));
00417             }
00418             bool b = __config->get_bool(path);
00419             config_bool_value_msg_t *r = prepare_msg<config_bool_value_msg_t>(path, (msg->msgid() == MSG_CONFIG_SET_DEFAULT_BOOL));
00420             r->b = (b ? 1 : 0);
00421             __hub->send(msg->clid(), FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_BOOL_VALUE,
00422                       r, sizeof(config_bool_value_msg_t));
00423           } catch (Exception &e) {
00424             send_inv_value(msg->clid(), path);
00425             LibLogger::log_warn("ConfigNetworkHandler",
00426                                 "set bool: Value %s could not be set", path);
00427             LibLogger::log_warn("ConfigNetworkHandler", e);
00428           }
00429           break;
00430         
00431         case MSG_CONFIG_SET_STRING:
00432         case MSG_CONFIG_SET_DEFAULT_STRING:
00433           try {
00434             config_string_value_msg_t *m = msg->msgge<config_string_value_msg_t>();
00435             if ( msg->msgid() == MSG_CONFIG_SET_STRING ) {
00436               __config->set_string(path, m->s);
00437             } else {
00438               __config->set_default_string(path, m->s);
00439             }
00440             std::string s = __config->get_string(path);
00441             size_t s_length = s.length();
00442             config_string_value_msg_t *r = prepare_string_msg<config_string_value_msg_t>(path, (msg->msgid() == MSG_CONFIG_SET_DEFAULT_STRING), s_length);
00443             strcpy(r->s, s.c_str());
00444             __hub->send(msg->clid(), FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_STRING_VALUE,
00445                       r, sizeof(config_string_value_msg_t) + s_length);
00446           } catch (Exception &e) {
00447             send_inv_value(msg->clid(), path);
00448             LibLogger::log_warn("ConfigNetworkHandler",
00449                                 "set string: Value %s could not be set", path);
00450             LibLogger::log_warn("ConfigNetworkHandler", e);
00451           }
00452           break;
00453 
00454         case MSG_CONFIG_SET_COMMENT:
00455         case MSG_CONFIG_SET_DEFAULT_COMMENT:
00456           try {
00457             config_comment_msg_t *m = msg->msgge<config_comment_msg_t>();
00458             std::string s = "";
00459             if ( msg->msgid() == MSG_CONFIG_SET_COMMENT ) {
00460               __config->set_comment(path, m->s);
00461               s = __config->get_comment(path);
00462             } else {
00463               __config->set_default_comment(path, m->s);
00464               s = __config->get_default_comment(path);
00465             }
00466             size_t s_length = s.length();
00467             config_comment_msg_t *r = prepare_string_msg<config_comment_msg_t>(path, (msg->msgid() == MSG_CONFIG_SET_DEFAULT_COMMENT), s_length);
00468             strcpy(r->s, s.c_str());
00469             __hub->send(msg->clid(), FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_COMMENT_VALUE,
00470                         r, sizeof(config_comment_msg_t) + s_length);
00471           } catch (Exception &e) {
00472             send_inv_value(msg->clid(), path);
00473             LibLogger::log_warn("ConfigNetworkHandler",
00474                                 "set comment: Value %s could not be set", path);
00475             LibLogger::log_warn("ConfigNetworkHandler", e);
00476           }
00477           break;
00478         
00479         }
00480       }
00481     }
00482 
00483 
00484     msg->unref();
00485     __inbound_queue.pop_locked();
00486   }
00487 }
00488 
00489 
00490 /** Handle network message.
00491  * The message is put into the inbound queue and processed in processAfterLoop().
00492  * @param msg message
00493  */
00494 void
00495 ConfigNetworkHandler::handle_network_message(FawkesNetworkMessage *msg)
00496 {
00497   msg->ref();
00498   __inbound_queue.push_locked(msg);
00499   wakeup();
00500 }
00501 
00502 
00503 /** Client connected.
00504  * Ignored.
00505  * @param clid client ID
00506  */
00507 void
00508 ConfigNetworkHandler::client_connected(unsigned int clid)
00509 {
00510 }
00511 
00512 
00513 /** Client disconnected.
00514  * If the client was a subscriber it is removed.
00515  * @param clid client ID
00516  */
00517 void
00518 ConfigNetworkHandler::client_disconnected(unsigned int clid)
00519 {
00520   __subscribers.lock();
00521   if (find(__subscribers.begin(), __subscribers.end(), clid) != __subscribers.end()) {
00522     LibLogger::log_warn("ConfigNetworkHandler",
00523                         "Client %u disconnected without closing the config, removing from list of subscribers",
00524                         clid);
00525     __subscribers.remove(clid);
00526   }
00527   __subscribers.unlock();
00528 }
00529 
00530 
00531 /** Tag changed.
00532  * Ignored.
00533  * @param new_tag new tag
00534  */
00535 void
00536 ConfigNetworkHandler::config_tag_changed(const char *new_tag)
00537 {
00538 }
00539 
00540 
00541 void
00542 ConfigNetworkHandler::config_value_changed(const char *path, bool is_default, int value)
00543 {
00544   __subscribers.lock();
00545   for (__sit = __subscribers.begin(); __sit != __subscribers.end(); ++__sit) {
00546     try {
00547       config_int_value_msg_t *r = prepare_msg<config_int_value_msg_t>(path, is_default);
00548       r->i = value;
00549       __hub->send(*__sit, FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_INT_VALUE,
00550                   r, sizeof(config_int_value_msg_t));
00551     } catch (Exception &e) {
00552       LibLogger::log_warn("ConfigNetworkHandler",
00553                           "config_value_changed[int]: Value for %s could not be sent "
00554                           "to client %u", path, *__sit);
00555       LibLogger::log_warn("ConfigNetworkHandler", e);
00556     }
00557   }
00558   __subscribers.unlock();
00559 }
00560 
00561 
00562 void
00563 ConfigNetworkHandler::config_value_changed(const char *path, bool is_default, unsigned int value)
00564 {
00565   __subscribers.lock();
00566   for (__sit = __subscribers.begin(); __sit != __subscribers.end(); ++__sit) {
00567     try {
00568       config_uint_value_msg_t *r = prepare_msg<config_uint_value_msg_t>(path, is_default);
00569       r->u = value;
00570       __hub->send(*__sit, FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_UINT_VALUE,
00571                   r, sizeof(config_uint_value_msg_t));
00572     } catch (Exception &e) {
00573       LibLogger::log_warn("ConfigNetworkHandler",
00574                           "config_value_changed[uint]: Value for %s could not be sent "
00575                           "to client %u", path, *__sit);
00576       LibLogger::log_warn("ConfigNetworkHandler", e);
00577     }
00578   }
00579   __subscribers.unlock();
00580 }
00581 
00582 
00583 void
00584 ConfigNetworkHandler::config_value_changed(const char *path, bool is_default, float value)
00585 {
00586   __subscribers.lock();
00587   for (__sit = __subscribers.begin(); __sit != __subscribers.end(); ++__sit) {
00588     try {
00589       config_float_value_msg_t *r = prepare_msg<config_float_value_msg_t>(path, is_default);
00590       r->f = value;
00591       __hub->send(*__sit, FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_FLOAT_VALUE,
00592                   r, sizeof(config_float_value_msg_t));
00593     } catch (Exception &e) {
00594       LibLogger::log_warn("ConfigNetworkHandler",
00595                           "config_value_changed[float]: Value for %s could not be sent "
00596                           "to client %u", path, *__sit);
00597       LibLogger::log_warn("ConfigNetworkHandler", e);
00598     }
00599   }
00600   __subscribers.unlock();
00601 }
00602 
00603 
00604 void
00605 ConfigNetworkHandler::config_value_changed(const char *path, bool is_default, bool value)
00606 {
00607   __subscribers.lock();
00608   for (__sit = __subscribers.begin(); __sit != __subscribers.end(); ++__sit) {
00609     try {
00610       config_bool_value_msg_t *r = prepare_msg<config_bool_value_msg_t>(path, is_default);
00611       r->b = (value ? 1 : 0);
00612       __hub->send(*__sit, FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_BOOL_VALUE,
00613                   r, sizeof(config_bool_value_msg_t));
00614     } catch (Exception &e) {
00615       LibLogger::log_warn("ConfigNetworkHandler",
00616                           "config_value_changed[bool]: Value for %s could not be sent "
00617                           "to client %u", path, *__sit);
00618       LibLogger::log_warn("ConfigNetworkHandler", e);
00619     }
00620   }
00621   __subscribers.unlock();
00622 }
00623 
00624 
00625 void
00626 ConfigNetworkHandler::config_value_changed(const char *path, bool is_default, const char *value)
00627 {
00628   __subscribers.lock();
00629   for (__sit = __subscribers.begin(); __sit != __subscribers.end(); ++__sit) {
00630     try {
00631       size_t s_length = strlen(value);
00632       config_string_value_msg_t *r = prepare_string_msg<config_string_value_msg_t>(path, is_default, s_length);
00633       strcpy(r->s, value);
00634       __hub->send(*__sit, FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_STRING_VALUE,
00635                   r, sizeof(config_string_value_msg_t) + s_length);
00636     } catch (Exception &e) {
00637       LibLogger::log_warn("ConfigNetworkHandler",
00638                           "config_value_changed[string]: Value for %s could not be sent "
00639                           "to client %u", path, *__sit);
00640       LibLogger::log_warn("ConfigNetworkHandler", e);
00641     }
00642   }
00643   __subscribers.unlock();
00644 }
00645 
00646 
00647 void
00648 ConfigNetworkHandler::config_comment_changed(const char *path, bool is_default, const char *comment)
00649 {
00650   __subscribers.lock();
00651   for (__sit = __subscribers.begin(); __sit != __subscribers.end(); ++__sit) {
00652     try {
00653       size_t s_length = strlen(comment);
00654       config_comment_msg_t *r = prepare_string_msg<config_comment_msg_t>(path, is_default, s_length);
00655       strcpy(r->s, comment);
00656 
00657       __hub->send(*__sit, FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_COMMENT_VALUE,
00658                   r, sizeof(config_comment_msg_t) + s_length);
00659     } catch (Exception &e) {
00660       LibLogger::log_warn("ConfigNetworkHandler",
00661                           "config_value_changed[string]: Value for %s could not be sent "
00662                           "to client %u", path, *__sit);
00663       LibLogger::log_warn("ConfigNetworkHandler", e);
00664     }
00665   }
00666   __subscribers.unlock();
00667 }
00668 
00669 
00670 void
00671 ConfigNetworkHandler::config_value_erased(const char *path, bool is_default)
00672 {
00673   __subscribers.lock();
00674   for (__sit = __subscribers.begin(); __sit != __subscribers.end(); ++__sit) {
00675     try {
00676       config_value_erased_msg_t *r = prepare_msg<config_value_erased_msg_t>(path, is_default);
00677       __hub->send(*__sit, FAWKES_CID_CONFIGMANAGER, MSG_CONFIG_VALUE_ERASED,
00678                 r, sizeof(config_value_erased_msg_t));
00679     } catch (Exception &e) {
00680       LibLogger::log_warn("ConfigNetworkHandler",
00681                           "configValueErased: Value for %s could not be sent "
00682                           "to client %u", path, *__sit);
00683     }
00684   }
00685   __subscribers.unlock();
00686 }
00687 
00688 } // end namespace fawkes
 All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator Friends