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