diku_mcs/Host.cc

   1 #include "Host.h"
   2 #include "macros.h"
   3
   4 namespace remote { namespace diku_mcs {
   5
   6 Host::Host( int fd, dbkey_t p_id, std::string ip, hostmapbykey_t& p_hostMap )
   7      : FileDescriptor(fd), id(p_id), message_in(), ipaddress(ip), hostMap(p_hostMap)
   8 {
   9         hostMap[id] = this;
  10         protocols::setSendTimeout( fd,5,0); // 5 second host send timeout should be adequate
  11         // set keepalive options: 3 attempts after 120 seconds, 30 second interval
  12         setKeepAlive( fd, 3, 120, 30);
  13 }
  14
  15 Host::~Host()
  16 {
  17         log("Closing host %s!\n",ipaddress.c_str());
  18         hostMap.erase(id);
  19 }
  20
  21 void Host::destroy(bool silent)
  22 {
  23         log("Deleting motes\n");
  24         motemapbymac_t::iterator mI;
  25         for( mI = motesByMac.begin(); mI != motesByMac.end(); mI++)
  26         {
  27                 if (mI->second) mI->second->destroy(silent);
  28         }
  29         delete this;
  30 }
  31
  32 void Host::registerMoteByMac(uint64_t mac,Mote* mote)
  33 {
  34         motemapbymac_t::iterator mI;
  35
  36         mI = motesByMac.find(mac);
  37
  38         if ( mI != motesByMac.end() )
  39         {
  40                 mI->second->destroy();
  41         }
  42
  43         motesByMac[mac] = mote;
  44 }
  45
  46 void Host::deleteMoteByMac(uint64_t mac)
  47 {
  48         motemapbymac_t::iterator mI;
  49         Mote* mote = NULL;
  50         mI = motesByMac.find(mac);
  51
  52         if ( mI != motesByMac.end() )
  53         {
  54                 mote = mI->second;
  55                 motesByMac.erase(mI);
  56         }
  57
  58         if (mote)
  59         {
  60                 mote->destroy();
  61         }
  62 }
  63
  64 void Host::registerMoteInfoByMac(uint64_t mac, moteinfo_t moteinfo)
  65 {
  66         moteInfoByMac[mac] = moteinfo;
  67 }
  68
  69 void Host::deleteMoteInfoByMac(uint64_t mac)
  70 {
  71         moteinfobymac_t::iterator mI;
  72         mI = moteInfoByMac.find(mac);
  73         if ( mI != moteInfoByMac.end() )
  74         {
  75                 moteInfoByMac.erase(mI);
  76         }
  77 }
  78
  79 void Host::findOrCreateMote(MsgMoteConnectionInfo& info)
  80 {
  81         mysqlpp::Connection& sqlConn = dbConn.getConnection();
  82         dbkey_t site_id, mote_id;
  83         Mote* mote;
  84         mysqlpp::ResUse selectRes;
  85         mysqlpp::ResNSel execRes;
  86         mysqlpp::Row row;
  87
  88         mysqlpp::Query siteselect = sqlConn.query();
  89         mysqlpp::Query moteselect = sqlConn.query();
  90         mysqlpp::Query tosselect = sqlConn.query();
  91
  92         mysqlpp::Query pathinsert = sqlConn.query();
  93         mysqlpp::Query macinsert = sqlConn.query();
  94         mysqlpp::Query tosinsert = sqlConn.query();
  95
  96         siteselect << "select site_id from path \
  97                        where host_id = %0:hostid \
  98                        and path='%1:path'";
  99
 100         moteselect << "select mote_id from macaddress \
 101                        where macaddress = %0:macaddress";
 102
 103         tosselect << "select tosaddress from tosaddress \
 104                       where mote_id = %0:mote_id";
 105
 106         pathinsert << "insert into path(host_id,path) \
 107                        values( %0:hostid,'%1:path' )";
 108
 109         macinsert << "insert into macaddress(macaddress,mote_id) \
 110                       values ( %0:macaddress,%1:mote_id)";
 111
 112         tosinsert << "insert into tosaddress(mote_id) values( %0:mote_id )";
 113
 114         moteselect.parse();
 115         siteselect.parse();
 116         tosselect.parse();
 117
 118         pathinsert.parse();
 119         macinsert.parse();
 120         tosinsert.parse();
 121
 122
 123         // look for the connection path + host id to get the site_id
 124         siteselect.def["hostid"] = id;
 125         siteselect.def["path"] = info.getPath().getString();
 126
 127         selectRes = siteselect.use();
 128         selectRes.disable_exceptions();
 129         row = selectRes.fetch_row();
 130         if ( !row || row.empty() )
 131         {
 132                 // if not found, create the path in the database with no site_id
 133                 pathinsert.def["hostid"] = id;
 134                 pathinsert.def["path"] = info.getPath().getString();
 135                 pathinsert.execute(); // TODO: error checking
 136
 137                 // get the newly inserted paths site_id
 138                 selectRes.purge();
 139                 selectRes = siteselect.use();
 140                 selectRes.disable_exceptions();
 141                 row = selectRes.fetch_row();
 142         }
 143
 144         // save the site_id
 145         site_id = (dbkey_t) row["site_id"];
 146
 147         // look for the mac addresses in the database, get mote_id
 148         moteselect.def["macaddress"] = info.macAddress;
 149
 150         selectRes.purge();
 151         selectRes = moteselect.use();
 152         selectRes.disable_exceptions();
 153         row = selectRes.fetch_row();
 154
 155         MoteAddresses* newtarget  = new MoteAddresses(0,info.macAddress);
 156
 157         if ( !row || row.empty() )
 158         {
 159                 selectRes.purge();
 160                 // create the mote using site_id only - the mote class will create the
 161                 // mote database record itself
 162                 mote = new Mote(site_id,(MoteControlInfrastructure&)*this,*newtarget);
 163                 // TODO: error checking
 164                 // create the mac and tos address database records using the mote id
 165                 macinsert.def["macaddress"] = info.macAddress;
 166                 macinsert.def["mote_id"] = mote->mote_id;
 167                 macinsert.execute();
 168                 tosinsert.def["mote_id"] = mote->mote_id;
 169                 execRes = tosinsert.execute();
 170                 newtarget->tosAddress = execRes.insert_id;
 171                 // FIXME: convert MAC address to hex string!!
 172                 //mote->setAttribute("macaddress",std::string::info.macAddress);
 173                 // TODO: tos address as well
 174         }
 175         else
 176         {
 177                 mote_id = (dbkey_t) row["mote_id"];   // save the mote_id
 178                 selectRes.purge();
 179                 // create the mote object using mote_id and site_id - the mote class will
 180                 // update the mote database record to reflect the new site
 181                 mote = new Mote(mote_id,site_id,(MoteControlInfrastructure&)*this,*newtarget);
 182
 183                 // add tosAddress as external mote info
 184                 tosselect.def["mote_id"] = mote_id; // get the tos address
 185                 selectRes = tosselect.use();
 186                 selectRes.disable_exceptions();
 187                 row = selectRes.fetch_row();
 188                 newtarget->tosAddress = (uint16_t)row["tosaddress"];
 189         }
 190
 191         if (mote)
 192         {
 193                 // finally, register the new mote in the local map
 194                 registerMoteByMac(info.macAddress,mote);
 195         }
 196 }
 197
 198 void Host::handleMotesLostList(MsgMoteConnectionInfoList& infolist)
 199 {
 200         MsgMoteConnectionInfo info;
 201         while ( infolist.getNextMoteInfo(info) )
 202         {
 203                 deleteMoteByMac(info.macAddress);
 204                 deleteMoteInfoByMac(info.macAddress);
 205         }
 206 }
 207
 208 void Host::handleMotesFoundList(MsgMoteConnectionInfoList& infolist)
 209 {
 210         MsgMoteConnectionInfo info;
 211
 212         while ( infolist.getNextMoteInfo(info) )
 213         {
 214                 uint8_t* m = (uint8_t*)&info.macAddress;
 215                 log("Mote %02x%02x%02x%02x %02x%02x%02x%02x plugged at %s\n",m[7],m[6],m[5],m[4],m[3],m[2],m[1],m[0],info.getPath().getString().c_str());
 216
 217                 findOrCreateMote(info);
 218         }
 219 }
 220
 221 void Host::request(MCIAddress& address, MsgPayload& request )
 222 {
 223         MsgMoteAddresses addresses(((MoteAddresses&)address).tosAddress,
 224                                    ((MoteAddresses&)address).macAddress);
 225         MsgHostRequest msgHostRequest(addresses,request);
 226         HostMsg message(msgHostRequest);
 227
 228         try {
 229                 Message msg;
 230                 msg.sendMsg(fd,message);
 231         }
 232         catch (remote::protocols::MMSException e)
 233         {
 234                 log("Exception: %s\n",e.what());
 235                 this->destroy(true);
 236         }
 237 }
 238
 239
 240 void Host::handleEvent(short events)
 241 {
 242
 243         if ( (events & POLLIN) || (events & POLLPRI) )
 244         {
 245                 if (!message_in.nonBlockingRecv(fd))
 246                 {
 247                          return;
 248                 }
 249
 250                 uint32_t msglen = message_in.getLength();
 251                 uint8_t* buffer = message_in.getData();
 252                 HostMsg message(buffer,msglen);
 253
 254                 switch (message.getType())
 255                 {
 256                         case HOSTMSGTYPE_HOSTCONFIRM:
 257                                 handleMsgIn(message.getHostConfirm());
 258                                 break;
 259                         case HOSTMSGTYPE_PLUGEVENT:
 260                                 if ( message.getPlugEvent().getType() == PLUG_MOTES )
 261                                 {
 262                                         handleMotesFoundList(message.getPlugEvent().getInfoList());
 263                                 }
 264                                 else if ( message.getPlugEvent().getType() == UNPLUG_MOTES )
 265                                 {
 266                                         handleMotesLostList(message.getPlugEvent().getInfoList());
 267                                 }
 268                                 else
 269                                 {
 270                                         __THROW__ ("Invalid plugevent received from host!");
 271                                 }
 272                                 break;
 273                         default:
 274                                 __THROW__ ("Invalid message type received from host!");
 275                                 break;
 276                 }
 277         }
 278         else if ( (events & POLLERR) || (events & POLLHUP) || (events & POLLNVAL) )
 279         {
 280                 __THROW__ ("Host connection error!\n");
 281         }
 282 }
 283
 284 void Host::handleMsgIn(MsgHostConfirm& msgHostConfirm)
 285 {
 286         motemapbymac_t::iterator mI;
 287         mI = motesByMac.find(msgHostConfirm.getMoteAddresses().getMacAddress());
 288         if ( mI != motesByMac.end() )
 289         {
 290                 if (msgHostConfirm.getStatus() == MSGHOSTCONFIRM_UNKNOWN_MOTE)
 291                 {
 292                         deleteMoteByMac(msgHostConfirm.getMoteAddresses().getMacAddress());
 293                         deleteMoteInfoByMac(msgHostConfirm.getMoteAddresses().getMacAddress());
 294                 } else {
 295                         mI->second->confirm(msgHostConfirm.getMessage());
 296                 }
 297         }
 298 }
 299
 300 }}