service/simulator/src/server/simulator_collection_resource_impl.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 "simulator_collection_resource_impl.h"
  22 #include "simulator_utils.h"
  23 #include "simulator_logger.h"
  24 #include "logger.h"
  25
  26 #define TAG "SIM_COLLECTION_RESOURCE"
  27
  28 SimulatorCollectionResourceImpl::SimulatorCollectionResourceImpl()
  29     :   m_type(SimulatorResource::Type::COLLECTION_RESOURCE),
  30         m_interfaces {OC::DEFAULT_INTERFACE, OC::LINK_INTERFACE},
  31         m_resourceHandle(NULL)
  32 {
  33     m_property = static_cast<OCResourceProperty>(OC_DISCOVERABLE | OC_OBSERVABLE);
  34
  35     std::vector<SimulatorResourceModel> links;
  36     m_resModel.add("links", links);
  37 }
  38
  39 std::string SimulatorCollectionResourceImpl::getName() const
  40 {
  41     return m_name;
  42 }
  43
  44 SimulatorResource::Type SimulatorCollectionResourceImpl::getType() const
  45 {
  46     return m_type;
  47 }
  48
  49 std::string SimulatorCollectionResourceImpl::getURI() const
  50 {
  51     return m_uri;
  52 }
  53
  54 std::string SimulatorCollectionResourceImpl::getResourceType() const
  55 {
  56     return m_resourceType;
  57 }
  58
  59 std::vector<std::string> SimulatorCollectionResourceImpl::getInterface() const
  60 {
  61     return m_interfaces;
  62 }
  63
  64 void SimulatorCollectionResourceImpl::setInterface(const std::vector<std::string> &interfaces)
  65 {
  66     m_interfaces = interfaces;
  67 }
  68
  69 void SimulatorCollectionResourceImpl::setName(const std::string &name)
  70 {
  71     VALIDATE_INPUT(name.empty(), "Name is empty!")
  72
  73     std::lock_guard<std::recursive_mutex> lock(m_objectLock);
  74     if (m_resourceHandle)
  75     {
  76         throw SimulatorException(SIMULATOR_OPERATION_NOT_ALLOWED,
  77                                  "Name can not be set when collection is started!");
  78     }
  79
  80     m_name = name;
  81 }
  82
  83 void SimulatorCollectionResourceImpl::setURI(const std::string &uri)
  84 {
  85     VALIDATE_INPUT(uri.empty(), "Uri is empty!")
  86
  87     std::lock_guard<std::recursive_mutex> lock(m_objectLock);
  88     if (m_resourceHandle)
  89     {
  90         throw SimulatorException(SIMULATOR_OPERATION_NOT_ALLOWED,
  91                                  "URI can not be set when collection is started!");
  92     }
  93
  94     m_uri = uri;
  95 }
  96
  97 void SimulatorCollectionResourceImpl::setResourceType(const std::string &resourceType)
  98 {
  99     VALIDATE_INPUT(resourceType.empty(), "Resource type is empty!")
 100
 101     std::lock_guard<std::recursive_mutex> lock(m_objectLock);
 102     if (m_resourceHandle)
 103     {
 104         throw SimulatorException(SIMULATOR_OPERATION_NOT_ALLOWED,
 105                                  "Resource type can not be set when collection is started!");
 106     }
 107
 108     m_resourceType = resourceType;
 109 }
 110
 111 void SimulatorCollectionResourceImpl::addInterface(std::string interfaceType)
 112 {
 113     VALIDATE_INPUT(interfaceType.empty(), "Interface type is empty!")
 114
 115     if (interfaceType == OC::GROUP_INTERFACE)
 116     {
 117         throw NoSupportException("Collection resource does not support this interface type!");
 118     }
 119
 120     std::lock_guard<std::recursive_mutex> lock(m_objectLock);
 121     if (m_resourceHandle)
 122     {
 123         throw SimulatorException(SIMULATOR_OPERATION_NOT_ALLOWED,
 124                                  "Interface type can not be set when resource is started!");
 125     }
 126
 127     auto found = std::find(m_interfaces.begin(), m_interfaces.end(), interfaceType);
 128     if (found != m_interfaces.end())
 129         m_interfaces.push_back(interfaceType);
 130 }
 131
 132 void SimulatorCollectionResourceImpl::setObservable(bool state)
 133 {
 134     std::lock_guard<std::recursive_mutex> lock(m_objectLock);
 135     if (m_resourceHandle)
 136     {
 137         throw SimulatorException(SIMULATOR_OPERATION_NOT_ALLOWED,
 138                                  "Observation state can not be changed when resource is started!");
 139     }
 140
 141     if (true == state)
 142         m_property = static_cast<OCResourceProperty>(m_property | OC_OBSERVABLE);
 143     else
 144         m_property = static_cast<OCResourceProperty>(m_property ^ OC_OBSERVABLE);
 145 }
 146
 147 void SimulatorCollectionResourceImpl::setObserverCallback(ObserverCallback callback)
 148 {
 149     VALIDATE_CALLBACK(callback)
 150     m_observeCallback = callback;
 151 }
 152
 153 void SimulatorCollectionResourceImpl::setModelChangeCallback(ResourceModelChangedCallback callback)
 154 {
 155     VALIDATE_CALLBACK(callback)
 156     m_modelCallback = callback;
 157 }
 158
 159 bool SimulatorCollectionResourceImpl::isObservable()
 160 {
 161     return (m_property & OC_OBSERVABLE);
 162 }
 163
 164 bool SimulatorCollectionResourceImpl::isStarted()
 165 {
 166     return (nullptr != m_resourceHandle);
 167 }
 168
 169 void SimulatorCollectionResourceImpl::start()
 170 {
 171     std::lock_guard<std::recursive_mutex> lock(m_objectLock);
 172     if (m_resourceHandle)
 173     {
 174         throw SimulatorException(SIMULATOR_ERROR, "Collection already registered!");
 175     }
 176
 177     if (m_uri.empty() || m_resourceType.empty())
 178     {
 179         throw SimulatorException(SIMULATOR_ERROR, "Found incomplete data to start resource!");
 180     }
 181
 182     typedef OCStackResult (*RegisterResource)(OCResourceHandle &, std::string &, const std::string &,
 183             const std::string &, OC::EntityHandler, uint8_t);
 184
 185     invokeocplatform(static_cast<RegisterResource>(OC::OCPlatform::registerResource),
 186                      m_resourceHandle, m_uri, m_resourceType, m_interfaces[0],
 187                      std::bind(&SimulatorCollectionResourceImpl::handleRequests,
 188                                this, std::placeholders::_1), m_property);
 189
 190     for (size_t index = 1; m_interfaces.size() > 1 && index < m_interfaces.size(); index++)
 191     {
 192         typedef OCStackResult (*bindInterfaceToResource)(const OCResourceHandle &,
 193                 const std::string &);
 194
 195         try
 196         {
 197             invokeocplatform(static_cast<bindInterfaceToResource>(
 198                                  OC::OCPlatform::bindInterfaceToResource), m_resourceHandle,
 199                              m_interfaces[index]);
 200         }
 201         catch (SimulatorException &e)
 202         {
 203             stop();
 204             throw;
 205         }
 206     }
 207 }
 208
 209 void SimulatorCollectionResourceImpl::stop()
 210 {
 211     std::lock_guard<std::recursive_mutex> lock(m_objectLock);
 212     if (!m_resourceHandle)
 213         return;
 214
 215     typedef OCStackResult (*UnregisterResource)(const OCResourceHandle &);
 216
 217     invokeocplatform(static_cast<UnregisterResource>(OC::OCPlatform::unregisterResource),
 218                      m_resourceHandle);
 219
 220     m_resourceHandle = nullptr;
 221 }
 222
 223 SimulatorResourceModel SimulatorCollectionResourceImpl::getResourceModel()
 224 {
 225     std::lock_guard<std::mutex> lock(m_modelLock);
 226     return m_resModel;
 227 }
 228
 229 void SimulatorCollectionResourceImpl::setResourceModel(const SimulatorResourceModel &resModel)
 230 {
 231     std::lock_guard<std::mutex> lock(m_modelLock);
 232     m_resModel = resModel;
 233 }
 234
 235 void SimulatorCollectionResourceImpl::setActionType(std::map<RAML::ActionType, RAML::ActionPtr> &actionType)
 236 {
 237     m_actionTypes = actionType;
 238 }
 239
 240 std::vector<ObserverInfo> SimulatorCollectionResourceImpl::getObserversList()
 241 {
 242     return m_observersList;
 243 }
 244
 245 void SimulatorCollectionResourceImpl::notify(int id)
 246 {
 247     std::lock_guard<std::recursive_mutex> lock(m_objectLock);
 248     if (!m_resourceHandle)
 249         return;
 250
 251     OC::ObservationIds observers {static_cast<OCObservationId>(id)};
 252     sendNotification(observers);
 253 }
 254
 255 void SimulatorCollectionResourceImpl::notifyAll()
 256 {
 257     std::lock_guard<std::recursive_mutex> lock(m_objectLock);
 258     if (!m_resourceHandle)
 259         return;
 260
 261     if (!m_observersList.size())
 262         return;
 263
 264     OC::ObservationIds observers;
 265     for (auto &observer : m_observersList)
 266         observers.push_back(observer.id);
 267     sendNotification(observers);
 268 }
 269
 270 std::vector<std::string> SimulatorCollectionResourceImpl::getSupportedResources()
 271 {
 272     return m_supportedTypes;
 273 }
 274
 275 void SimulatorCollectionResourceImpl::addChildResource(SimulatorResourceSP &resource)
 276 {
 277     VALIDATE_INPUT(!resource, "Invalid child resource!")
 278
 279     std::lock_guard<std::mutex> lock(m_childResourcesLock);
 280     if (m_childResources.end() != m_childResources.find(resource->getURI()))
 281     {
 282         throw SimulatorException(SIMULATOR_ERROR, "Child resource with same URI is already exisit!");
 283     }
 284
 285     m_childResources[resource->getURI()] = resource;
 286     addLink(resource);
 287
 288     // Notify application and observers
 289     if (m_modelCallback)
 290         m_modelCallback(m_uri, m_resModel);
 291     notifyAll();
 292 }
 293
 294 void SimulatorCollectionResourceImpl::removeChildResource(SimulatorResourceSP &resource)
 295 {
 296     VALIDATE_INPUT(!resource, "Invalid child resource!")
 297
 298     std::lock_guard<std::mutex> lock(m_childResourcesLock);
 299     if (m_childResources.end() == m_childResources.find(resource->getURI()))
 300     {
 301         throw SimulatorException(SIMULATOR_ERROR, "Child resource not found in collection!");
 302     }
 303
 304     removeLink(resource->getURI());
 305     m_childResources.erase(m_childResources.find(resource->getURI()));
 306
 307     // Notify application and observers
 308     if (m_modelCallback)
 309         m_modelCallback(m_uri, m_resModel);
 310     notifyAll();
 311 }
 312
 313 void SimulatorCollectionResourceImpl::removeChildResource(const std::string &uri)
 314 {
 315     VALIDATE_INPUT(uri.empty(), "Uri is empty!")
 316
 317     std::lock_guard<std::mutex> lock(m_childResourcesLock);
 318     if (m_childResources.end() == m_childResources.find(uri))
 319     {
 320         throw SimulatorException(SIMULATOR_ERROR, "Child resource not found in collection!");
 321     }
 322
 323     removeLink(uri);
 324     m_childResources.erase(m_childResources.find(uri));
 325
 326     // Notify application and observers
 327     if (m_modelCallback)
 328         m_modelCallback(m_uri, m_resModel);
 329     notifyAll();
 330 }
 331
 332 std::vector<SimulatorResourceSP> SimulatorCollectionResourceImpl::getChildResources()
 333 {
 334     std::lock_guard<std::mutex> lock(m_childResourcesLock);
 335
 336     std::vector<SimulatorResourceSP> result;
 337     for (auto &entry : m_childResources)
 338         result.push_back(entry.second);
 339
 340     return result;
 341 }
 342
 343 OCEntityHandlerResult SimulatorCollectionResourceImpl::handleRequests(
 344     std::shared_ptr<OC::OCResourceRequest> request)
 345 {
 346     if (!request)
 347         return OC_EH_ERROR;
 348
 349     if (OC::RequestHandlerFlag::RequestFlag & request->getRequestHandlerFlag())
 350     {
 351         {
 352             OC::OCRepresentation rep = request->getResourceRepresentation();
 353             std::string payload = getPayloadString(rep);
 354             SIM_LOG(ILogger::INFO, "[" << m_name << "] " << request->getRequestType()
 355                     << " request received. \n**Payload details**\n" << payload)
 356         }
 357
 358         // Handover the request to appropriate interface handler
 359         std::string interfaceType(OC::DEFAULT_INTERFACE);
 360         OC::QueryParamsMap queryParams = request->getQueryParameters();
 361         if (queryParams.end() != queryParams.find("if"))
 362             interfaceType = queryParams["if"];
 363
 364         std::shared_ptr<OC::OCResourceResponse> response;
 365         if (interfaceType == OC::DEFAULT_INTERFACE)
 366         {
 367             response = requestOnBaseLineInterface(request);
 368         }
 369         else if (interfaceType == OC::LINK_INTERFACE)
 370         {
 371             response = requestOnLinkListInterface(request);
 372         }
 373         else if (interfaceType == OC::BATCH_INTERFACE)
 374         {
 375             response = requestOnBatchInterface(request);
 376         }
 377
 378         // Send response if the request handled by resource
 379         if (response)
 380         {
 381             if (OC_STACK_OK != OC::OCPlatform::sendResponse(response))
 382                 return OC_EH_ERROR;
 383         }
 384         else
 385         {
 386             SIM_LOG(ILogger::ERROR, "[" << m_name << "] " << "Unsupported request received!")
 387             return OC_EH_ERROR;
 388         }
 389     }
 390
 391     if (OC::RequestHandlerFlag::ObserverFlag & request->getRequestHandlerFlag())
 392     {
 393         if (!isObservable())
 394         {
 395             SIM_LOG(ILogger::INFO, "[" << m_uri << "] OBSERVE request received")
 396             SIM_LOG(ILogger::INFO, "[" << m_uri << "] Sending error as resource is in unobservable state!")
 397             return OC_EH_ERROR;
 398         }
 399
 400         OC::ObservationInfo observationInfo = request->getObservationInfo();
 401         if (OC::ObserveAction::ObserveRegister == observationInfo.action)
 402         {
 403             SIM_LOG(ILogger::INFO, "[" << m_uri << "] OBSERVE REGISTER request received");
 404
 405             ObserverInfo info {observationInfo.obsId, observationInfo.address, observationInfo.port};
 406             m_observersList.push_back(info);
 407
 408             if (m_observeCallback)
 409                 m_observeCallback(m_uri, ObservationStatus::REGISTER, info);
 410         }
 411         else if (OC::ObserveAction::ObserveUnregister == observationInfo.action)
 412         {
 413             SIM_LOG(ILogger::INFO, "[" << m_uri << "] OBSERVE UNREGISTER request received");
 414
 415             ObserverInfo info;
 416             for (auto iter = m_observersList.begin(); iter != m_observersList.end(); iter++)
 417             {
 418                 if ((info = *iter), info.id == observationInfo.obsId)
 419                 {
 420                     m_observersList.erase(iter);
 421                     break;
 422                 }
 423             }
 424
 425             if (m_observeCallback)
 426                 m_observeCallback(m_uri, ObservationStatus::UNREGISTER, info);
 427         }
 428     }
 429
 430     return OC_EH_OK;
 431 }
 432
 433 std::shared_ptr<OC::OCResourceResponse> SimulatorCollectionResourceImpl::requestOnBaseLineInterface(
 434     std::shared_ptr<OC::OCResourceRequest> request)
 435 {
 436     std::shared_ptr<OC::OCResourceResponse> response;
 437
 438     RAML::ActionType type = getActionType(request->getRequestType());
 439
 440     if (!m_actionTypes.empty())
 441     {
 442         if (m_actionTypes.end() == m_actionTypes.find(type))
 443             return response;
 444     }
 445
 446     if ("GET" == request->getRequestType())
 447     {
 448         // Construct the representation
 449         OC::OCRepresentation ocRep = m_resModel.getOCRepresentation();
 450         response = std::make_shared<OC::OCResourceResponse>();
 451         response->setErrorCode(200);
 452         response->setResponseResult(OC_EH_OK);
 453         response->setResourceRepresentation(ocRep);
 454         std::string resPayload = getPayloadString(ocRep);
 455         SIM_LOG(ILogger::INFO, "[" << m_uri <<
 456                 "] Sending response for GET request. \n**Payload details**" << resPayload)
 457     }
 458
 459     // TODO: Handle PUT, POST and DELETE requests
 460
 461     if (response)
 462     {
 463         response->setRequestHandle(request->getRequestHandle());
 464         response->setResourceHandle(request->getResourceHandle());
 465     }
 466
 467     return response;
 468 }
 469
 470 std::shared_ptr<OC::OCResourceResponse> SimulatorCollectionResourceImpl::requestOnLinkListInterface(
 471     std::shared_ptr<OC::OCResourceRequest> request)
 472 {
 473     std::lock_guard<std::mutex> lock(m_childResourcesLock);
 474     std::shared_ptr<OC::OCResourceResponse> response;
 475
 476     RAML::ActionType type = getActionType(request->getRequestType());
 477
 478     if (!m_actionTypes.empty())
 479     {
 480         if (m_actionTypes.end() == m_actionTypes.find(type))
 481             return response;
 482     }
 483
 484     if ("GET" == request->getRequestType())
 485     {
 486         // Construct the representation
 487         OC::OCRepresentation ocRep;
 488         std::vector<OC::OCRepresentation> links;
 489         for (auto &entry : m_childResources)
 490         {
 491             OC::OCRepresentation oicLink;
 492             oicLink.setValue("href", entry.second->getURI());
 493             oicLink.setValue("rt", entry.second->getResourceType());
 494             oicLink.setValue("if", entry.second->getInterface()[0]);
 495             links.push_back(oicLink);
 496         }
 497
 498         ocRep.setValue("links", links);
 499
 500         response = std::make_shared<OC::OCResourceResponse>();
 501         response->setRequestHandle(request->getRequestHandle());
 502         response->setResourceHandle(request->getResourceHandle());
 503         response->setErrorCode(200);
 504         response->setResponseResult(OC_EH_OK);
 505         response->setResourceRepresentation(ocRep);
 506         std::string resPayload = getPayloadString(ocRep);
 507         SIM_LOG(ILogger::INFO, "[" << m_uri <<
 508                 "] Sending response for GET request. \n**Payload details**" << resPayload)
 509     }
 510
 511     return nullptr;
 512 }
 513
 514 std::shared_ptr<OC::OCResourceResponse> SimulatorCollectionResourceImpl::requestOnBatchInterface(
 515     std::shared_ptr<OC::OCResourceRequest>)
 516 {
 517     // TODO: Handle this interface
 518     return nullptr;
 519 }
 520
 521 void SimulatorCollectionResourceImpl::sendNotification(OC::ObservationIds &observers)
 522 {
 523     std::lock_guard<std::recursive_mutex> lock(m_objectLock);
 524     std::shared_ptr<OC::OCResourceResponse> response(new OC::OCResourceResponse());
 525     response->setErrorCode(200);
 526     response->setResponseResult(OC_EH_OK);
 527
 528     OC::OCRepresentation ocRep = m_resModel.getOCRepresentation();
 529     response->setResourceRepresentation(ocRep, OC::DEFAULT_INTERFACE);
 530
 531     typedef OCStackResult (*NotifyListOfObservers)(OCResourceHandle, OC::ObservationIds &,
 532             const std::shared_ptr<OC::OCResourceResponse>);
 533
 534     invokeocplatform(static_cast<NotifyListOfObservers>(OC::OCPlatform::notifyListOfObservers),
 535                      m_resourceHandle, observers, response);
 536 }
 537
 538 void SimulatorCollectionResourceImpl::addLink(SimulatorResourceSP &resource)
 539 {
 540     std::lock_guard<std::mutex> lock(m_modelLock);
 541     if (!m_resModel.containsAttribute("links"))
 542         return;
 543
 544     // Create new OIC Link
 545     SimulatorResourceModel newLink;
 546     newLink.add("href", resource->getURI());
 547     newLink.add("rt", resource->getResourceType());
 548     newLink.add("if", resource->getInterface()[0]);
 549
 550     // Add OIC Link if it is not present
 551     bool found = false;
 552     std::vector<SimulatorResourceModel> links =
 553         m_resModel.get<std::vector<SimulatorResourceModel>>("links");
 554     for (auto &link : links)
 555     {
 556         std::string linkURI = link.get<std::string>("href");
 557         if (linkURI == resource->getURI())
 558         {
 559             break;
 560             found = true;
 561         }
 562     }
 563
 564     if (false ==  found)
 565     {
 566         links.push_back(newLink);
 567         m_resModel.updateValue("links", links);
 568     }
 569 }
 570
 571 void SimulatorCollectionResourceImpl::removeLink(std::string uri)
 572 {
 573     std::lock_guard<std::mutex> lock(m_modelLock);
 574     if (!m_resModel.containsAttribute("links"))
 575         return;
 576
 577     // Add OIC Link if it is not present
 578     std::vector<SimulatorResourceModel> links =
 579         m_resModel.get<std::vector<SimulatorResourceModel>>("links");
 580     for (size_t i = 0; i < links.size(); i++)
 581     {
 582         std::string linkURI = links[i].get<std::string>("href");
 583         if (linkURI == uri)
 584         {
 585             links.erase(links.begin() + i);
 586             m_resModel.updateValue("links", links);
 587             break;
 588         }
 589     }
 590 }
 591
 592 RAML::ActionType SimulatorCollectionResourceImpl::getActionType(std::string requestType)
 593 {
 594     if (!requestType.compare("GET"))
 595         return RAML::ActionType::GET;
 596
 597     if (!requestType.compare("PUT"))
 598         return RAML::ActionType::PUT;
 599
 600     if (!requestType.compare("POST"))
 601         return RAML::ActionType::POST;
 602
 603     if (!requestType.compare("DELETE"))
 604         return RAML::ActionType::DELETE;
 605
 606     return RAML::ActionType::NONE;
 607 }