service/resource-encapsulation/src/resourceBroker/src/ResourceBroker.cpp

   1 //******************************************************************
   2 //
   3 // Copyright 2015 Samsung Electronics All Rights Reserved.
   4 //
   5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   6 //
   7 // Licensed under the Apache License, Version 2.0 (the "License");
   8 // you may not use this file except in compliance with the License.
   9 // You may obtain a copy of the License at
  10 //
  11 //      http://www.apache.org/licenses/LICENSE-2.0
  12 //
  13 // Unless required by applicable law or agreed to in writing, software
  14 // distributed under the License is distributed on an "AS IS" BASIS,
  15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 // See the License for the specific language governing permissions and
  17 // limitations under the License.
  18 //
  19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  20
  21 #include <time.h>
  22
  23 #include "BrokerTypes.h"
  24 #include "ResourceBroker.h"
  25
  26 namespace OIC
  27 {
  28     namespace Service
  29     {
  30         ResourceBroker * ResourceBroker::s_instance = NULL;
  31         std::mutex ResourceBroker::s_mutexForCreation;
  32         std::unique_ptr<PresenceList>  ResourceBroker::s_presenceList(nullptr);
  33         std::unique_ptr<BrokerIDMap> ResourceBroker::s_brokerIDMap(nullptr);
  34
  35         ResourceBroker::~ResourceBroker()
  36         {
  37             if(s_presenceList != nullptr)
  38             {
  39                 OC_LOG_V(DEBUG, BROKER_TAG, "clear the ResourcePresenceList.");
  40                 s_presenceList->erase(s_presenceList->begin(), s_presenceList->end());
  41                 s_presenceList->clear();
  42             }
  43             if(s_brokerIDMap != nullptr)
  44             {
  45                 OC_LOG_V(DEBUG, BROKER_TAG, "clear the brokerIDMap.");
  46                 s_brokerIDMap->erase(s_brokerIDMap->begin(), s_brokerIDMap->end());
  47                 s_brokerIDMap->clear();
  48             }
  49         }
  50
  51         ResourceBroker * ResourceBroker::getInstance()
  52         {
  53             if (!s_instance)
  54             {
  55                 s_mutexForCreation.lock();
  56                 if (!s_instance)
  57                 {
  58                     s_instance = new ResourceBroker();
  59                     s_instance->initializeResourceBroker();
  60                 }
  61                 s_mutexForCreation.unlock();
  62             }
  63             return s_instance;
  64         }
  65
  66         BrokerID ResourceBroker::hostResource(PrimitiveResourcePtr pResource, BrokerCB cb)
  67         {
  68             OC_LOG_V(DEBUG, BROKER_TAG, "hostResource().");
  69             if(pResource == nullptr || cb == nullptr || cb == NULL)
  70             {
  71                 throw InvalidParameterException("[hostResource] input parameter(PrimitiveResource or BrokerCB) is Invalid");
  72             }
  73
  74             BrokerID retID = generateBrokerID();
  75
  76             ResourcePresencePtr presenceItem = findResourcePresence(pResource);
  77             if(presenceItem == nullptr)
  78             {
  79                 OC_LOG_V(DEBUG, BROKER_TAG, "Not found any Handled Resource.");
  80                 OC_LOG_V(DEBUG, BROKER_TAG, "Create New Resource Presence Handler.");
  81
  82                 try
  83                 {
  84                     OC_LOG_V(DEBUG, BROKER_TAG, "create the ResourcePresence.");
  85                     presenceItem.reset(new ResourcePresence());
  86                     presenceItem->initializeResourcePresence(pResource);
  87                 }catch(PlatformException &e)
  88                 {
  89                     throw FailedSubscribePresenceException(e.getReasonCode());
  90                 }
  91                 if(s_presenceList != nullptr)
  92                 {
  93                     OC_LOG_V(DEBUG, BROKER_TAG, "push the ResourcePresence in presenceList.");
  94                     s_presenceList->push_back(presenceItem);
  95                 }
  96             }
  97             OC_LOG_V(DEBUG, BROKER_TAG, "add the BrokerRequester in ResourcePresence.");
  98             presenceItem->addBrokerRequester(retID, cb);
  99
 100             BrokerCBResourcePair pair(presenceItem, cb);
 101             s_brokerIDMap->insert(std::pair<BrokerID, BrokerCBResourcePair>
 102                 (retID, BrokerCBResourcePair(presenceItem, cb)));
 103
 104             return retID;
 105         }
 106
 107         void ResourceBroker::cancelHostResource(BrokerID brokerId)
 108         {
 109             OC_LOG_V(DEBUG,BROKER_TAG,"cancelHostResource().");
 110             if(brokerId == 0)
 111             {
 112                 // input parameter is wrong.
 113                 // hostResource never return value 0;
 114                 OC_LOG_V(DEBUG,BROKER_TAG,"brokerId is zero.");
 115                 throw InvalidParameterException("[cancelHostResource] brokerId is invalid.");
 116             }
 117
 118             BrokerIDMap::iterator it = s_brokerIDMap->find(brokerId);
 119             if(it == s_brokerIDMap->end())
 120             {
 121                 // not found requested brokerId in BrokerMap;
 122                 OC_LOG_V(DEBUG,BROKER_TAG,"brokerId is not found in brokerIDMap.");
 123                 throw InvalidParameterException("[cancelHostResource] brokerId is not found in brokerIDMap.");
 124             }
 125             else
 126             {
 127                 ResourcePresencePtr presenceItem = it->second.pResource;
 128                 presenceItem->removeBrokerRequester(brokerId);
 129                 s_brokerIDMap->erase(brokerId);
 130
 131                 if(presenceItem->isEmptyRequester())
 132                 {
 133                     OC_LOG_V(DEBUG,BROKER_TAG,"remove resourcePresence in presenceList because it is not including any requester info.");
 134                     s_presenceList->remove(presenceItem);
 135                 }
 136             }
 137         }
 138
 139         BROKER_STATE ResourceBroker::getResourceState(BrokerID brokerId)
 140         {
 141             OC_LOG_V(DEBUG,BROKER_TAG,"getResourceState().");
 142             if(brokerId == 0)
 143             {
 144                 OC_LOG_V(DEBUG,BROKER_TAG,"brokerId is zero.");
 145                 throw InvalidParameterException("[getResourceState] input BrokerID is Invalid");
 146             }
 147
 148             BROKER_STATE retState = BROKER_STATE::NONE;
 149
 150             BrokerIDMap::iterator it = s_brokerIDMap->find(brokerId);
 151             if(it == s_brokerIDMap->end())
 152             {
 153                 // not found requested brokerId in BrokerMap;
 154                 OC_LOG_V(DEBUG,BROKER_TAG,"brokerId is not found in brokerIDMap.");
 155                 throw InvalidParameterException("[getResourceState] input BrokerID is unknown ID");
 156             }
 157             else
 158             {
 159                 ResourcePresencePtr foundResource = it->second.pResource;
 160                 retState = foundResource->getResourceState();
 161             }
 162
 163             return retState;
 164         }
 165
 166         BROKER_STATE ResourceBroker::getResourceState(PrimitiveResourcePtr pResource)
 167         {
 168             OC_LOG_V(DEBUG,BROKER_TAG,"getResourceState().");
 169             if(pResource == nullptr)
 170             {
 171                 throw InvalidParameterException("[getResourceState] input PrimitiveResource is Invalid");
 172             }
 173
 174             BROKER_STATE retState = BROKER_STATE::NONE;
 175
 176             ResourcePresencePtr foundResource = findResourcePresence(pResource);
 177             if(foundResource != nullptr)
 178             {
 179                 retState = foundResource->getResourceState();
 180             }
 181
 182             return retState;
 183         }
 184
 185         void ResourceBroker::initializeResourceBroker()
 186         {
 187             OC_LOG_V(DEBUG,BROKER_TAG,"initializeResourceBroker().");
 188             if(s_presenceList == nullptr)
 189             {
 190                 OC_LOG_V(DEBUG,BROKER_TAG,"create the presenceList.");
 191                 s_presenceList = std::unique_ptr<PresenceList>(new PresenceList);
 192             }
 193             if(s_brokerIDMap == nullptr)
 194             {
 195                 OC_LOG_V(DEBUG,BROKER_TAG,"create the brokerIDMap.");
 196                 s_brokerIDMap = std::unique_ptr<BrokerIDMap>(new BrokerIDMap);
 197             }
 198         }
 199
 200         ResourcePresencePtr ResourceBroker::findResourcePresence(PrimitiveResourcePtr pResource)
 201         {
 202             OC_LOG_V(DEBUG,BROKER_TAG,"findResourcePresence().");
 203             ResourcePresencePtr retResource(nullptr);
 204
 205             if(s_presenceList->empty() != true)
 206             {
 207                 for(auto & it : * s_presenceList)
 208                 {
 209                     PrimitiveResourcePtr temp = it->getPrimitiveResource();
 210                     if(temp == pResource)
 211                     {
 212                         retResource = it;
 213                         break;
 214                     }
 215                 }
 216             }
 217
 218             return retResource;
 219         }
 220
 221         BrokerID ResourceBroker::generateBrokerID()
 222         {
 223             OC_LOG_V(DEBUG,BROKER_TAG,"generateBrokerID().");
 224             BrokerID retID = 0;
 225             srand(time(NULL));
 226
 227             while(1)
 228             {
 229                 if(retID != 0 && s_brokerIDMap->find(retID) == s_brokerIDMap->end())
 230                 {
 231                     break;
 232                 }
 233                 retID = (unsigned int)rand();
 234             }
 235
 236             return retID;
 237         }
 238     } // namespace Service
 239 } // namespace OIC