src_client/DeviceManagerClient.cc

   1 /*
   2  * DeviceManagerClient.cc
   3  *
   4  *  Created on: Mar 4, 2011
   5  *      Author: lamikr
   6  */
   7 #include <sstream>
   8 #include <string>
   9
  10 #include <plp/log.h>
  11 #include <plp/retval.h>
  12
  13 #include <plp/Data.hh>
  14 #include <plp/DeviceData.hh>
  15
  16 #include "DeviceManagerClient.hh"
  17 #include "../src/plp/devicebus/DeviceBusMessageId.hh"
  18
  19 using namespace std;
  20 using namespace plp;
  21 using namespace plpbus;
  22 using namespace plpdevicebus;
  23
  24 DeviceManagerClient::DeviceManagerClient() {
  25         _device_list    = NULL;
  26 }
  27
  28 static void clean_device_list(list<Device *> *dev_lst) {
  29         Device  *dev;
  30
  31         if (dev_lst != NULL) {
  32                 while (dev_lst->empty() == false) {
  33                         dev     = dev_lst->back();
  34                         dev_lst->pop_back();
  35                         delete(dev);
  36                 }
  37                 delete(dev_lst);
  38                 dev_lst = NULL;
  39         }
  40 }
  41
  42 DeviceManagerClient::~DeviceManagerClient() {
  43         clean_device_list(_device_list);
  44 }
  45
  46 list<Device *> *DeviceManagerClient::parse_device_list_msg(BusMessage *msg_param,
  47                                                         int *err_flg) {
  48         int                             ii;
  49         long                            count;
  50         ostringstream                   key;
  51         string                          id;
  52         string                          name;
  53         string                          type;
  54         string                          datastr;
  55         EnumDeviceLifeCycleStatus       state;
  56         int                             state_i;
  57         Device                          *dev;
  58         Data                            *data;
  59         list<Device *>                  *ret_val;
  60
  61         ret_val = new list<Device *>;
  62         count   = msg_param->get_long_parameter(RSP__DEVICE_LIST__DEVICE_COUNT, err_flg);
  63         log_debug("device count: %ld\n", count);
  64         if (*err_flg == PLP_OK) {
  65                 for (ii = 0; ii < count; ii++) {
  66                         data    = NULL;
  67
  68                         key.str("");
  69                         key << RSP__DEVICE_LIST__ID << ii;
  70                         id      = msg_param->get_string_parameter(key.str(), err_flg);
  71                         if (*err_flg != PLP_OK) {
  72                                 log_error("Failed to parse device id.\n");
  73                                 break;
  74                         }
  75
  76                         key.str("");
  77                         key << RSP__DEVICE_LIST__NAME << ii;
  78                         name    = msg_param->get_string_parameter(key.str(), err_flg);
  79                         if (*err_flg != PLP_OK) {
  80                                 log_error("Failed to parse name for the device: %s\n", id.c_str());
  81                                 break;
  82                         }
  83
  84                         key.str("");
  85                         key << RSP__DEVICE_LIST__TYPE << ii;
  86                         type    = msg_param->get_string_parameter(key.str(), err_flg);
  87                         if (*err_flg != PLP_OK) {
  88                                 log_error("Failed to parse type for the device: %s\n", id.c_str());
  89                                 break;
  90                         }
  91
  92                         key.str("");
  93                         key << RSP__DEVICE_LIST__LF_STATE << ii;
  94                         state_i = msg_param->get_int_parameter(key.str(), err_flg);
  95                         if (*err_flg != PLP_OK) {
  96                                 log_error("Failed to parse life cycle state for the device: %s\n", id.c_str());
  97                                 break;
  98                         }
  99                         state   = (EnumDeviceLifeCycleStatus)state_i;
 100
 101                         key.str("");
 102                         key << RSP__DEVICE_LIST__DATA << ii;
 103                         datastr = msg_param->get_string_parameter(key.str(), err_flg);
 104                         if (*err_flg == PLP_OK) {
 105                                 data    = Data::parse_string(datastr);
 106                                 if (data == NULL) {
 107                                         log_error("No data available for the device: %s\n", id.c_str());
 108                                 }
 109                         }
 110                         else {
 111                                 log_error("No data available for the device: %s\n", id.c_str());
 112                         }
 113                         dev     = new DeviceData(id, type, name, state, data);
 114                         ret_val->push_back(dev);
 115                 }
 116         }
 117         return ret_val;
 118 }
 119
 120 const std::list<plp::Device *> *DeviceManagerClient::get_device_list(BusClient *client_param,
 121                                                                 int *err_flg) {
 122         BusMessage      *msg_req;
 123         BusMessage      *msg_rsp;
 124
 125         msg_rsp = NULL;
 126         msg_req = new BusMessage(MSG_TYPE_ID__GET_DEVICE_LIST);
 127         client_param->send_message_and_wait_response(msg_req, &msg_rsp);
 128         clean_device_list(_device_list);
 129         _device_list    = parse_device_list_msg(msg_rsp, err_flg);
 130         delete(msg_req);
 131         delete(msg_rsp);
 132
 133         return _device_list;
 134 }
 135
 136 void DeviceManagerClient::parse_device_data_msg(BusMessage *msg_param,
 137                                         DataRange *result,
 138                                         string key_str,
 139                                         int *err_flg,
 140                                         string description) {
 141         string          data_str;
 142         Data            *data;
 143
 144         *err_flg        = PLP_ERR;
 145         data            = NULL;
 146         if ((msg_param != NULL) &&
 147             (result != NULL)) {
 148                 data_str        = msg_param->get_string_parameter(key_str, err_flg);
 149                 if (data_str.empty() == false) {
 150                         data    = Data::parse_string(data_str);
 151                 }
 152                 if (data != NULL) {
 153                         result->add(data);
 154                         log_debug("%s\n", description.c_str());
 155                         data->printout();
 156                         delete(data);
 157                 }
 158         }
 159 }
 160
 161 DataRange *DeviceManagerClient::parse_device_data_msg(BusMessage *msg_param,
 162                                                 int *err_flg) {
 163         DataRange       *ret_val;
 164
 165         *err_flg        = PLP_ERR;
 166         ret_val         = NULL;
 167         if (msg_param != NULL) {
 168                 ret_val         = new DataRange();
 169                 parse_device_data_msg(msg_param, ret_val, RSP__LATEST_DATA_VALUE, err_flg, "latest data");
 170                 parse_device_data_msg(msg_param, ret_val, RSP__MIN_DATA_VALUE, err_flg, "latest min data value");
 171                 parse_device_data_msg(msg_param, ret_val, RSP__MAX_DATA_VALUE, err_flg, "latest max data value");
 172
 173                 *err_flg        = PLP_OK;
 174         }
 175         return ret_val;
 176 }
 177
 178 Data *DeviceManagerClient::get_latest_data(BusClient *client_param,
 179                                         string device_id_param,
 180                                         int *err_flg) {
 181         BusMessage      *msg_req;
 182         BusMessage      *msg_rsp;
 183         Data            *ret_val;
 184         DataRange       *dr;
 185
 186         msg_rsp = NULL;
 187         ret_val = NULL;
 188         msg_req = new BusMessage(MSG_TYPE_ID__GET_LATEST_DATA);
 189         msg_req->add_string_parameter(REQ__DEVICE_ID, device_id_param.c_str());
 190         client_param->send_message_and_wait_response(msg_req, &msg_rsp);
 191         dr      = parse_device_data_msg(msg_rsp, err_flg);
 192         ret_val = dr->get_first();
 193         delete(dr);
 194         delete(msg_req);
 195         delete(msg_rsp);
 196
 197         return ret_val;
 198 }
 199
 200 DataRange *DeviceManagerClient::parse_data_range_msg(BusMessage *msg_param,
 201                                                 int *err_flg) {
 202         DataRange       *ret_val;
 203
 204         *err_flg        = PLP_ERR;
 205         ret_val         = NULL;
 206         if (msg_param != NULL) {
 207                 ret_val         = new DataRange();
 208                 parse_device_data_msg(msg_param, ret_val, RSP__FIRST_DATA_VALUE, err_flg, "first data");
 209                 parse_device_data_msg(msg_param, ret_val, RSP__LATEST_DATA_VALUE, err_flg, "latest data");
 210                 *err_flg        = PLP_OK;
 211         }
 212         return ret_val;
 213 }
 214
 215 DataRange *DeviceManagerClient::get_data_range(BusClient *client_param,
 216                                         string device_id_param,
 217                                         int *err_flg) {
 218         BusMessage      *msg_req;
 219         BusMessage      *msg_rsp;
 220         DataRange       *ret_val;
 221
 222         msg_rsp = NULL;
 223         ret_val = NULL;
 224         msg_req = new BusMessage(MSG_TYPE_ID__GET_DATA_RANGE);
 225         msg_req->add_string_parameter(REQ__DEVICE_ID, device_id_param.c_str());
 226         client_param->send_message_and_wait_response(msg_req, &msg_rsp);
 227         ret_val = parse_data_range_msg(msg_rsp, err_flg);
 228         delete(msg_req);
 229         delete(msg_rsp);
 230
 231         return ret_val;
 232 }