src_server/DeviceManagerServer.cc

   1 /*
   2  * DeviceManager.cc
   3  *
   4  *  Created on: Mar 3, 2011
   5  *      Author: lamikr
   6  */
   7 #include <sstream>
   8 #include <typeinfo>
   9
  10 #include <plp/log.h>
  11 #include <plp/retval.h>
  12
  13 #include <plp/Data.hh>
  14 #include <plp/Device.hh>
  15 #include <plp/SensorDevice.hh>
  16 #include <plp/DeviceConfig.hh>
  17
  18 #include "DeviceManagerServer.hh"
  19 #include "../src/plp/devicebus/DeviceBusMessageId.hh"
  20
  21 using namespace plpdevicebus;
  22
  23 static void *device_data_reader_thread(void *thread_args_pointer) {
  24         list<Device *>                  *_dev_lst;
  25         list<Device *>::iterator        list_iter;
  26         Device                          *device;
  27         SensorDevice                    *sensor;
  28         long                            read_int_sec;
  29         plp::Data                       *data;
  30
  31         read_int_sec    = DeviceConfig::get_read_interval_seconds();
  32         if (read_int_sec < 0)
  33                 read_int_sec = 600;
  34         _dev_lst        = (list<Device *> *)thread_args_pointer;
  35         while(1) {
  36                 for (list_iter = _dev_lst->begin(); list_iter != _dev_lst->end(); list_iter++) {
  37                         device  = (Device *)*list_iter;
  38                         sensor = dynamic_cast<SensorDevice *>(device);
  39                         if (sensor != NULL) {
  40                                 data = sensor->get_data();
  41                                 if (data != NULL)
  42                                         delete(data);
  43                         }
  44                 }
  45                 sleep(read_int_sec);
  46         }
  47         pthread_exit(NULL);
  48 }
  49
  50 DeviceManagerServer::DeviceManagerServer(list<Device *> dev_lst_param) {
  51         //DeviceConfig::set_base_dir_name(storage_dir_param);
  52         //_dev_lst      = Factory::get_device_list();
  53         _dev_lst        = dev_lst_param;
  54         /* In some toolchains the size is not unsigned int instead of long
  55            unsigned int, and that can cause warnings/errors without typecasting
  56          */
  57         log_info("device count: %lu\n", (long unsigned int)_dev_lst.size());
  58         _lstnr_thrd     = 0;
  59         pthread_create(&_lstnr_thrd,
  60                         NULL,
  61                         device_data_reader_thread,
  62                         (void *)&_dev_lst);
  63 }
  64
  65 DeviceManagerServer::~DeviceManagerServer() {
  66 }
  67
  68 void decode_device_to_busmessage(const BusMessage *ret_val,
  69                                 Device *device,
  70                                 int indx) {
  71         ostringstream   key;
  72         SensorDevice    *sensor;
  73         Data            *data;
  74         string          data_str;
  75
  76         if ((ret_val != NULL) &&
  77             (device != NULL)) {
  78                 key.str("");
  79                 key << RSP__DEVICE_LIST__ID << indx;
  80                 ((BusMessage *)ret_val)->add_string_parameter(key.str(), device->get_id());
  81
  82                 key.str("");
  83                 key << RSP__DEVICE_LIST__NAME << indx;
  84                 ((BusMessage *)ret_val)->add_string_parameter(key.str(), device->get_name());
  85
  86                 key.str("");
  87                 key << RSP__DEVICE_LIST__TYPE << indx;
  88                 ((BusMessage *)ret_val)->add_string_parameter(key.str(), device->get_type());
  89
  90                 key.str("");
  91                 key << RSP__DEVICE_LIST__LF_STATE << indx;
  92                 ((BusMessage *)ret_val)->add_int_parameter(key.str(), device->get_lifecycle_state());
  93                 sensor = dynamic_cast<SensorDevice *>(device);
  94                 if (sensor != NULL) {
  95                         key.str("");
  96                         key << RSP__DEVICE_LIST__DATA << indx;
  97                         data    = sensor->get_data();
  98                         if (data != NULL) {
  99                                 data_str        = data->to_string();
 100                                 log_debug("returning data: %s\n", data_str.c_str());
 101                                 ((BusMessage *)ret_val)->add_string_parameter(key.str(), data_str);
 102                                 delete(data);
 103                         }
 104                 }
 105         }
 106 }
 107
 108 void DeviceManagerServer::get_device_list(const BusMessage *ret_val) {
 109         list<Device *>::iterator        list_iter;
 110         Device                          *device;
 111         int                             indx;
 112
 113         indx    = 0;
 114         ((BusMessage *)ret_val)->add_int_parameter(RSP__DEVICE_LIST__DEVICE_COUNT, _dev_lst.size());
 115         for (list_iter = _dev_lst.begin(); list_iter != _dev_lst.end(); list_iter++) {
 116                 device  = (Device *)*list_iter;
 117                 decode_device_to_busmessage(ret_val,
 118                                         device,
 119                                         indx);
 120                 indx++;
 121         }
 122 }
 123
 124 const Device *DeviceManagerServer::get_device_by_id(string id_param) {
 125         Device                  *ret_val;
 126         Device                  *device;
 127         list<Device *>::iterator list_iter;
 128
 129         ret_val = NULL;
 130         for(list_iter = _dev_lst.begin(); list_iter != _dev_lst.end(); list_iter++) {
 131                 device  = (Device *)*list_iter;
 132                 if (device != NULL) {
 133                         if (device->get_id().compare(id_param) == 0) {
 134                                 ret_val = device;
 135                                 break;
 136                         }
 137                 }
 138         }
 139         return ret_val;
 140 }
 141
 142 static void add_data_values_to_bus_message(const BusMessage *msg_rsp_param,
 143                                         Data *data,
 144                                         string key_name_base_param) {
 145         string val_str;
 146
 147         val_str = data->to_string();
 148         ((BusMessage *)msg_rsp_param)->add_string_parameter(key_name_base_param, val_str);
 149 }
 150
 151 void decode_latest_data_to_busmessage(const BusMessage *ret_val,
 152                         const DataReader *reader) {
 153         DataRange       *dr;
 154         Data            *data;
 155
 156         data    = ((DataReader *)reader)->get_latest_data();
 157         if (data != NULL) {
 158                 add_data_values_to_bus_message(ret_val,
 159                                         data,
 160                                         RSP__LATEST_DATA_VALUE);
 161                 //((BusMessage *)ret_val)->printout();
 162                 delete(data);
 163         }
 164         dr      = ((DataReader *)reader)->get_daily_summary(MIN);
 165         if (dr != NULL) {
 166                 if (dr->get_count() > 0) {
 167                         data    = dr->get_first();;
 168                         add_data_values_to_bus_message(ret_val,
 169                                         data,
 170                                         RSP__MIN_DATA_VALUE);
 171                         delete(data);
 172                 }
 173                 delete(dr);
 174         }
 175         dr      = ((DataReader *)reader)->get_daily_summary(MAX);
 176         if (dr != NULL) {
 177                 if (dr->get_count() > 0) {
 178                         data    = dr->get_first();
 179                         add_data_values_to_bus_message(ret_val,
 180                                                 data,
 181                                                 RSP__MAX_DATA_VALUE);
 182                         delete(data);
 183                 }
 184                 delete(dr);
 185         }
 186 }
 187
 188 void decode_first_and_last_data_to_busmessage(const BusMessage *ret_val,
 189                                                 DataRange *dr) {
 190         Data    *data;
 191
 192         data    = dr->get_first();
 193         if (data != NULL) {
 194                 add_data_values_to_bus_message(ret_val,
 195                                         data,
 196                                         RSP__FIRST_DATA_VALUE);
 197                 //((BusMessage *)ret_val)->printout();
 198                 delete(data);
 199         }
 200         data    = dr->get_last();
 201         if (data != NULL) {
 202                 add_data_values_to_bus_message(ret_val,
 203                                         data,
 204                                         RSP__LATEST_DATA_VALUE);
 205                 //((BusMessage *)ret_val)->printout();
 206                 delete(data);
 207         }
 208 }
 209
 210 void decode_data_range_to_busmessage(const BusMessage *ret_val,
 211                                 DataRange *dr) {
 212         Data            *data;
 213         int             ii;
 214         int             count;
 215         ostringstream   key;
 216
 217         count   = dr->get_count();
 218         ((BusMessage *)ret_val)->add_int_parameter(RSP__COUNT, count);
 219         for (ii = 0; ii < count; ii++) {
 220                 data    = dr->get(ii);
 221                 if (data != NULL) {
 222                         key.str("");
 223                         key << RSP__DATA_VALUE << ii;
 224                         add_data_values_to_bus_message(ret_val,
 225                                                 data,
 226                                                 key.str());
 227                         delete(data);
 228                 }
 229         }
 230 }
 231
 232 void DeviceManagerServer::get_latest_data(BusMessage *msg_req_param,
 233                                         const BusMessage *ret_val) {
 234         string                  id;
 235         int                     err_flg;
 236         Device                  *dev;
 237         SensorDevice            *sensor;
 238         ostringstream           key;
 239         const DataReader        *reader;
 240
 241         id      = msg_req_param->get_string_parameter(REQ__DEVICE_ID, &err_flg);
 242         if (err_flg == PLP_OK) {
 243                 dev     = (Device *)get_device_by_id(id);
 244                 if (dev != NULL) {
 245                         sensor  = dynamic_cast<SensorDevice *>(dev);
 246                         if (sensor != NULL) {
 247                                 reader  = sensor->get_datareader();
 248                                 decode_latest_data_to_busmessage(ret_val, reader);
 249                         }
 250                 }
 251         }
 252 }
 253
 254 void DeviceManagerServer::get_data_range(BusMessage *msg_req_param,
 255                                         const BusMessage *ret_val) {
 256         string                  id;
 257         int                     err_flg;
 258         Device                  *dev;
 259         SensorDevice            *sensor;
 260         ostringstream           key;
 261         const DataReader        *reader;
 262         DataRange               *dr;
 263
 264         id      = msg_req_param->get_string_parameter(REQ__DEVICE_ID, &err_flg);
 265         if (err_flg == PLP_OK) {
 266                 dev     = (Device *)get_device_by_id(id);
 267                 if (dev != NULL) {
 268                         sensor  = dynamic_cast<SensorDevice *>(dev);
 269                         if (sensor != NULL) {
 270                                 reader  = sensor->get_datareader();
 271                                 if (reader != NULL) {
 272                                         dr      = ((DataReader *)reader)->get_data_range();
 273                                         if (dr != NULL) {
 274                                                 decode_first_and_last_data_to_busmessage(ret_val, dr);
 275                                                 delete(dr);
 276                                         }
 277                                 }
 278                         }
 279                 }
 280         }
 281 }
 282
 283 void DeviceManagerServer::get_data_between_dates(BusMessage *msg_req_param,
 284                                         const BusMessage *ret_val) {
 285         string                  id;
 286         int                     err_flg;
 287         Device                  *dev;
 288         SensorDevice            *sensor;
 289         ostringstream           key;
 290         const DataReader        *reader;
 291         DataRange               *dr;
 292         string                  startdate_str;
 293         string                  enddate_str;
 294         Date                    sdate;
 295         Date                    edate;
 296
 297         log_debug("started\n");
 298         id              = msg_req_param->get_string_parameter(REQ__DEVICE_ID, &err_flg);
 299         if (err_flg == PLP_OK)
 300                 startdate_str   = msg_req_param->get_string_parameter(REQ__DATE1, &err_flg);
 301         if (err_flg == PLP_OK)
 302                 enddate_str     = msg_req_param->get_string_parameter(REQ__DATE2, &err_flg);
 303         log_debug("id: %s, sdate: %s, edate: %s\n", id.c_str(), startdate_str.c_str(), enddate_str.c_str());
 304         if (err_flg == PLP_OK) {
 305                 sdate   = Date::parse_date_str(startdate_str);
 306                 edate   = Date::parse_date_str(enddate_str);
 307                 log_debug("id: %s, sdate: %s, edate: %s\n", id.c_str(), startdate_str.c_str(), enddate_str.c_str());
 308                 dev     = (Device *)get_device_by_id(id);
 309                 if (dev != NULL) {
 310                         sensor  = dynamic_cast<SensorDevice *>(dev);
 311                         if (sensor != NULL) {
 312                                 reader  = sensor->get_datareader();
 313                                 if (reader != NULL) {
 314                                         dr      = ((DataReader *)reader)->get_data(&sdate, &edate);
 315                                         log_debug("dr.size: %d\n", dr->get_count());
 316                                         if (dr != NULL) {
 317                                                 decode_data_range_to_busmessage(ret_val, dr);
 318                                                 delete(dr);
 319                                         }
 320                                 }
 321                         }
 322                 }
 323         }
 324         else {
 325                 log_error("Invalid request parameters.\n");
 326         }
 327 }