location of unittest is moved to resource-hosting\ from resource-hosting\src\.
and code refactoring of resource hosting source files.
removed local variables and modified more simple logic.
Change-Id: Ic018e699ecd7e9f3d1d66a8914409573b4732cb4
Signed-off-by: jyong2.kim <jyong2.kim@samsung.com>
Reviewed-on: https://gerrit.iotivity.org/gerrit/4311
Tested-by: jenkins-iotivity <jenkins-iotivity@opendaylight.org>
Reviewed-by: Hun-je Yeon <hunje.yeon@samsung.com>
Reviewed-by: Madan Lanka <lanka.madan@samsung.com>
# Go to build Unit test
if target_os == 'linux':
- SConscript('src/unittest/SConscript')
+ SConscript('unittest/SConscript')
# Go to build sample apps
SConscript('SampleApp/SConscript')
OIC_HOSTING_LOG(DEBUG,
"[OICStartCoordinate] platformException, reason:%s", e.what());
retResult = OC_STACK_ERROR;
- throw;
}catch(const RCSInvalidParameterException &e)
{
OIC_HOSTING_LOG(DEBUG,
"[OICStartCoordinate] InvalidParameterException, reason:%s", e.what());
retResult = OC_STACK_ERROR;
- throw;
}catch(...)
{
OIC_HOSTING_LOG(DEBUG, "[OICStartCoordinate] Unknown Exception");
retResult = OC_STACK_ERROR;
}
-
return retResult;
}
OCStackResult OICStopCoordinate()
{
- OCStackResult retResult = OC_STACK_OK;
OIC::Service::ResourceHosting::getInstance()->stopHosting();
-
- return retResult;
+ return OC_STACK_OK;
}
void OIC_HOSTING_LOG(LogLevel level, const char * format, ...)
{
- if (!format)
- {
- return;
- }
+ if (!format) return;
char buffer[MAX_LOG_V_BUFFER_SIZE] = {};
va_list args;
va_start(args, format);
namespace
{
- std::mutex mutexForCB;
+ const auto sizeofHostingTag = strlen("/hosting");
}
HostingObject::HostingObject()
: remoteObject(nullptr), mirroredServer(nullptr),
- remoteState(ResourceState::NONE),
- pStateChangedCB(nullptr), pDataUpdateCB(nullptr),
- pDestroyCB(nullptr), pSetRequestHandler(nullptr)
+ pDataUpdateCB(nullptr), pDestroyCB(nullptr)
{
}
HostingObject::~HostingObject()
{
- // shared_ptr release
- pStateChangedCB = {};
pDataUpdateCB = {};
if (remoteObject)
}
}
-HostingObject::RemoteObjectPtr HostingObject::getRemoteResource() const
+auto HostingObject::getRemoteResource() const -> RemoteObjectPtr
{
return remoteObject;
}
-void HostingObject::initializeHostingObject(RemoteObjectPtr rResource, DestroyedCallback destroyCB)
+auto HostingObject::createHostingObject(const RemoteObjectPtr & rResource,
+ DestroyedCallback destroyCB) -> Ptr
{
- remoteObject = rResource;
+ auto newObject = std::make_shared<HostingObject>();
- pStateChangedCB = std::bind(&HostingObject::stateChangedCB, this,
- std::placeholders::_1, remoteObject);
- pDataUpdateCB = std::bind(&HostingObject::dataChangedCB, this,
- std::placeholders::_1, remoteObject);
- pDestroyCB = destroyCB;
+ newObject->remoteObject = rResource;
+ newObject->pDestroyCB = destroyCB;
- pSetRequestHandler = std::bind(&HostingObject::setRequestHandler, this,
- std::placeholders::_1, std::placeholders::_2);
+ newObject->pDataUpdateCB = std::bind(&HostingObject::dataChangedCB, newObject,
+ std::placeholders::_1);
- try
- {
- remoteObject->startMonitoring(pStateChangedCB);
- remoteObject->startCaching(pDataUpdateCB);
- }catch(...)
- {
- throw;
- }
+ newObject->remoteObject->startMonitoring(
+ std::bind(&HostingObject::stateChangedCB, newObject,
+ std::placeholders::_1));
+ newObject->remoteObject->startCaching(newObject->pDataUpdateCB);
+
+ return newObject;
}
void HostingObject::destroyHostingObject()
{
- pDestroyCB();
+ if(pDestroyCB) pDestroyCB();
}
-void HostingObject::stateChangedCB(ResourceState state, RemoteObjectPtr rObject)
+void HostingObject::stateChangedCB(ResourceState state)
{
- remoteState = state;
-
switch (state)
{
case ResourceState::ALIVE:
{
- if(rObject->isCaching() == false)
+ if(!this->remoteObject->isCaching())
{
try
{
- rObject->startCaching(pDataUpdateCB);
- }catch(const RCSInvalidParameterException &e)
+ this->remoteObject->startCaching(pDataUpdateCB);
+ }catch(const RCSException &e)
{
OIC_HOSTING_LOG(DEBUG,
"[HostingObject::stateChangedCB]startCaching InvalidParameterException:%s",
case ResourceState::LOST_SIGNAL:
case ResourceState::DESTROYED:
{
- if(rObject->isCaching() == true)
+ try
{
- try
- {
- rObject->stopCaching();
- }catch(const RCSInvalidParameterException &e)
- {
- OIC_HOSTING_LOG(DEBUG,
- "[HostingObject::stateChangedCB]stopCaching InvalidParameterException:%s",
- e.what());
- }
+ this->remoteObject->stopCaching();
+ this->remoteObject->stopMonitoring();
}
- if(rObject->isMonitoring() == true)
+ catch(const RCSException &e)
{
- try
- {
- rObject->stopMonitoring();
- }catch(const RCSInvalidParameterException &e)
- {
- OIC_HOSTING_LOG(DEBUG,
- "[HostingObject::stateChangedCB]stopWatching InvalidParameterException:%s",
- e.what());
- }
+ OIC_HOSTING_LOG(DEBUG,
+ "[HostingObject::stateChangedCB]stopWatching InvalidParameterException:%s",
+ e.what());
}
- mirroredServer = nullptr;
+ mirroredServer.reset();
destroyHostingObject();
break;
}
}
}
-void HostingObject::dataChangedCB(const RCSResourceAttributes & attributes, RemoteObjectPtr rObject)
+void HostingObject::dataChangedCB(const RCSResourceAttributes & attributes)
{
- std::unique_lock<std::mutex> lock(mutexForCB);
if(attributes.empty())
{
return;
}
- if(mirroredServer == nullptr)
- {
- try
- {
- mirroredServer = createMirroredServer(rObject);
- }catch(const RCSPlatformException &e)
- {
- OIC_HOSTING_LOG(DEBUG,
- "[HostingObject::dataChangedCB]createMirroredServer PlatformException:%s",
- e.what());
- mirroredServer = nullptr;
- return;
- }
- }
-
- RCSResourceAttributes rData;
- {
- RCSResourceObject::LockGuard guard(mirroredServer);
- rData = mirroredServer->getAttributes();
- }
- if(rData.empty() || rData != attributes)
{
+ std::unique_lock<std::mutex> lock(mutexForCB);
+ if(mirroredServer == nullptr)
{
- RCSResourceObject::LockGuard guard(mirroredServer);
- for(auto it = rData.begin(); ; ++it)
+ try
{
- if(it == rData.end())
- {
- break;
- }
- mirroredServer->removeAttribute(it->key());
- }
-
- for(auto it = attributes.begin();; ++it)
+ mirroredServer = createMirroredServer(this->remoteObject);
+ }catch(const RCSException &e)
{
- if(it == attributes.end())
- {
- break;
- }
- mirroredServer->setAttribute(it->key(), it->value());
+ OIC_HOSTING_LOG(DEBUG,
+ "[HostingObject::dataChangedCB]createMirroredServer Exception:%s",
+ e.what());
+ return;
}
}
}
+
+ RCSResourceObject::LockGuard guard(mirroredServer);
+ mirroredServer->getAttributes() = std::move(attributes);
}
-HostingObject::ResourceObjectPtr HostingObject::createMirroredServer(RemoteObjectPtr rObject)
+auto HostingObject::createMirroredServer(RemoteObjectPtr rObject) -> ResourceObjectPtr
{
- ResourceObjectPtr retResource = nullptr;
- if(rObject != nullptr)
- {
- std::string fulluri = rObject->getUri();
- std::string uri = fulluri.substr(0, fulluri.size()-8);
- std::vector<std::string> types = rObject->getTypes();
- std::vector<std::string> interfaces = rObject->getInterfaces();
- try
- {
- std::string type = types.begin()->c_str();
- std::string interface = interfaces.begin()->c_str();
- retResource = RCSResourceObject::Builder(uri, type, interface).
- setDiscoverable(true).setObservable(true).build();
-
- // TODO need to bind types and interfaces
- retResource->setAutoNotifyPolicy(RCSResourceObject::AutoNotifyPolicy::UPDATED);
- retResource->setSetRequestHandler(pSetRequestHandler);
- }catch(...)
- {
- OIC_HOSTING_LOG(DEBUG, "[HostingObject::createMirroredServer] %s", "PlatformException");
- throw;
- }
- }
- else
+ if(rObject == nullptr)
{
throw RCSPlatformException(OC_STACK_ERROR);
}
- return retResource;
+ std::string fulluri = rObject->getUri();
+ std::string uri = fulluri.substr(0, fulluri.size() - sizeofHostingTag);
+ std::vector<std::string> types = rObject->getTypes();
+ std::vector<std::string> interfaces = rObject->getInterfaces();
+ try
+ {
+ auto retResource = RCSResourceObject::Builder(uri, types[0], interfaces[0]).build();
+
+ // TODO need to bind types and interfaces
+ retResource->setAutoNotifyPolicy(RCSResourceObject::AutoNotifyPolicy::UPDATED);
+ retResource->setSetRequestHandler(
+ std::bind(&HostingObject::setRequestHandler, this,
+ std::placeholders::_1, std::placeholders::_2));
+ return retResource;
+ }catch(...)
+ {
+ OIC_HOSTING_LOG(DEBUG, "[HostingObject::createMirroredServer] %s", "Exception");
+ throw;
+ }
}
RCSSetResponse HostingObject::setRequestHandler(const RCSRequest & primitiveRequest,
try
{
RequestObject newRequest = { };
- newRequest.invokeRequest(remoteObject, RequestObject::RequestMethod::Setter,
+ newRequest.invokeRequest(remoteObject, RequestObject::RequestMethod::Set,
resourceAttibutes);
}catch(const RCSPlatformException &e)
{
throw;
}
- return RCSSetResponse::create(resourceAttibutes);
+ return RCSSetResponse::defaultAction();
}
} /* namespace Service */
#define RH_HOSTINGOBJECT_H_
#include "logger.h"
-
#include "RCSRemoteResourceObject.h"
#include "RCSResourceObject.h"
#include "RequestObject.h"
void OIC_HOSTING_LOG(LogLevel level, const char * format, ...);
-class HostingObject
+class HostingObject : public std::enable_shared_from_this<HostingObject>
{
private:
- typedef std::shared_ptr<RCSResourceObject> ResourceObjectPtr;
- typedef std::shared_ptr<RCSRemoteResourceObject> RemoteObjectPtr;
- typedef std::shared_ptr<RequestObject> RequestObjectPtr;
- typedef std::shared_ptr<PrimitiveResource> PrimiteveResourcePtr;
+ typedef RCSResourceObject::Ptr ResourceObjectPtr;
+ typedef RequestObject::Ptr RequestObjectPtr;
+ typedef RCSRemoteResourceObject::Ptr RemoteObjectPtr;
public:
typedef std::shared_ptr<HostingObject> Ptr;
- typedef std::function<void(ResourceState)> BrokerCallback;
- typedef std::function<void(const RCSResourceAttributes &)> CacheCallback;
- typedef std::function<void()> DestroyedCallback;
+ typedef std::weak_ptr<HostingObject> wPtr;
- typedef std::function<
- RCSSetResponse(const RCSRequest&, RCSResourceAttributes&)> SetRequestHandler;
+ typedef std::function<void()> DestroyedCallback;
+ typedef RCSRemoteResourceObject::StateChangedCallback BrokerCallback;
+ typedef RCSRemoteResourceObject::CacheUpdatedCallback CacheCallback;
+ typedef RCSResourceObject::SetRequestHandler SetRequestHandler;
public:
HostingObject();
~HostingObject();
- void initializeHostingObject(RemoteObjectPtr rResource, DestroyedCallback destroyCB);
+ HostingObject(const HostingObject&) = delete;
+ HostingObject(HostingObject&&) = delete;
+ HostingObject& operator=(HostingObject&&) = delete;
+ HostingObject& operator=(const HostingObject&) = delete;
+
+ static HostingObject::Ptr createHostingObject(const RemoteObjectPtr & rResource,
+ DestroyedCallback destroyCB);
RemoteObjectPtr getRemoteResource() const;
RemoteObjectPtr remoteObject;
ResourceObjectPtr mirroredServer;
- ResourceState remoteState;
-
- BrokerCallback pStateChangedCB;
CacheCallback pDataUpdateCB;
DestroyedCallback pDestroyCB;
- SetRequestHandler pSetRequestHandler;
+ std::mutex mutexForCB;
ResourceObjectPtr createMirroredServer(RemoteObjectPtr rObject);
- void stateChangedCB(ResourceState state, RemoteObjectPtr rObject);
- void dataChangedCB(const RCSResourceAttributes & attributes, RemoteObjectPtr rObject);
-
RCSSetResponse setRequestHandler(
const RCSRequest & request, RCSResourceAttributes & attributes);
void destroyHostingObject();
+public:
+ void stateChangedCB(ResourceState state);
+ void dataChangedCB(const RCSResourceAttributes & attributes);
};
} /* namespace Service */
namespace Service
{
-RequestObject::RequestObject() : pSetRequestCB(nullptr){ }
-RequestObject::RequestObject(SetRequestCallback cb) : pSetRequestCB(cb){ };
+RequestObject::RequestObject()
+: pSetRequestCB(nullptr)
+{
+}
+
+RequestObject::RequestObject(SetRequestCallback cb)
+: pSetRequestCB(cb)
+{
+}
RequestObject::~RequestObject()
{
}
void RequestObject::invokeRequest(RemoteObjectPtr remoteObject, RequestMethod method,
- RCSResourceAttributes & resourceAttibutes)
+ const RCSResourceAttributes & resourceAttibutes)
{
- try
+ switch (method)
{
- switch (method)
- {
- case RequestMethod::Setter:
+ case RequestMethod::Set:
+ {
+ if(pSetRequestCB == nullptr)
{
- if(pSetRequestCB == nullptr)
- {
- remoteObject->setRemoteAttributes(resourceAttibutes,
- std::bind(&RequestObject::setRequestCB, this,
- std::placeholders::_1, resourceAttibutes));
- }
- else
- {
- remoteObject->setRemoteAttributes(resourceAttibutes,
- std::bind(pSetRequestCB,
- std::placeholders::_1, resourceAttibutes));
- }
+ remoteObject->setRemoteAttributes(resourceAttibutes,
+ std::bind(&RequestObject::setRequestCB, this,
+ std::placeholders::_1, resourceAttibutes));
}
- break;
- case RequestMethod::Getter:
- case RequestMethod::Delete:
- default:
- // unknown type of method.
- break;
+ else
+ {
+ remoteObject->setRemoteAttributes(resourceAttibutes,
+ std::bind(pSetRequestCB,
+ std::placeholders::_1, resourceAttibutes));
}
- }catch(...)
- {
- throw;
+ }
+ break;
+ case RequestMethod::Get:
+ case RequestMethod::Delete:
+ default:
+ // unknown type of method.
+ break;
}
}
void RequestObject::setRequestCB(const RCSResourceAttributes & returnedAttributes,
- RCSResourceAttributes & putAttibutes)
+ const RCSResourceAttributes & putAttibutes)
{
if(putAttibutes != returnedAttributes)
{
{
public:
typedef std::shared_ptr<RequestObject> Ptr;
- typedef std::shared_ptr<RCSRemoteResourceObject> RemoteObjectPtr;
- typedef void (*SetRequestCallback)(const RCSResourceAttributes &, RCSResourceAttributes &);
+ typedef std::function<
+ void(const RCSResourceAttributes &, const RCSResourceAttributes &)> SetRequestCallback;
enum class RequestMethod
{
- Getter = 0,
- Setter,
+ Get = 0,
+ Set,
+ Post,
Delete
};
private:
+ typedef RCSRemoteResourceObject::Ptr RemoteObjectPtr;
+
SetRequestCallback pSetRequestCB;
public:
~RequestObject();
void invokeRequest(RemoteObjectPtr remoteObject, RequestMethod method,
- RCSResourceAttributes & resourceAttibutes);
+ const RCSResourceAttributes & resourceAttibutes);
private:
void setRequestCB(const RCSResourceAttributes & returnedAttributes,
- RCSResourceAttributes & putAttibutes);
+ const RCSResourceAttributes & putAttibutes);
};
} /* namespace Service */
#include "PresenceSubscriber.h"
#include "OCPlatform.h"
#include "RCSDiscoveryManager.h"
+#include "RCSAddress.h"
namespace OIC
{
namespace
{
- std::string HOSTING_TAG = "/hosting";
- size_t HOSTING_TAG_SIZE = (size_t)HOSTING_TAG.size();
- std::string MULTICAST_PRESENCE_ADDRESS = std::string("coap://") + OC_MULTICAST_PREFIX;
- std::string HOSTING_RESOURSE_TYPE = "oic.r.resourcehosting";
+ const std::string HOSTING_TAG = "/hosting";
+ const auto HOSTING_TAG_SIZE = HOSTING_TAG.size();
+ const std::string MULTICAST_PRESENCE_ADDRESS = std::string("coap://") + OC_MULTICAST_PREFIX;
+ const std::string HOSTING_RESOURSE_TYPE = "oic.r.resourcehosting";
}
-ResourceHosting * ResourceHosting::s_instance(nullptr);
-std::mutex ResourceHosting::s_mutexForCreation;
-
ResourceHosting::ResourceHosting()
-: hostingObjectList(),
- discoveryManager(nullptr),
- pDiscoveryCB(nullptr)
+: m_mutexForList(),
+ m_isStartedHosting(false),
+ m_hostingObjects(),
+ m_discoveryTask()
{
}
ResourceHosting * ResourceHosting::getInstance()
{
- if (!s_instance)
- {
- s_mutexForCreation.lock();
- if (!s_instance)
- {
- s_instance = new ResourceHosting();
- s_instance->initializeResourceHosting();
- }
- s_mutexForCreation.unlock();
- }
- return s_instance;
+ static ResourceHosting instance;
+ return & instance;
}
void ResourceHosting::startHosting()
{
- try
- {
- requestMulticastDiscovery();
- }catch(const RCSPlatformException &e)
- {
- OIC_HOSTING_LOG(DEBUG,
- "[ResourceHosting::startHosting]PlatformException:%s", e.what());
- throw;
- }catch(const RCSInvalidParameterException &e)
- {
- OIC_HOSTING_LOG(DEBUG,
- "[ResourceHosting::startHosting]InvalidParameterException:%s", e.what());
- throw;
- }catch(const std::exception &e)
- {
- OIC_HOSTING_LOG(DEBUG,
- "[ResourceHosting::startHosting]std::exception:%s", e.what());
- throw;
- }
+ if(m_isStartedHosting) return;
+ m_isStartedHosting = true;
+ createDiscoveryListener();
}
void ResourceHosting::stopHosting()
{
+ if(!m_isStartedHosting) return;
- hostingObjectList.clear();
-}
+ if(!m_discoveryTask->isCanceled())
+ {
+ m_discoveryTask->cancel();
+ }
-void ResourceHosting::initializeResourceHosting()
-{
- pDiscoveryCB = std::bind(&ResourceHosting::discoverHandler, this,
- std::placeholders::_1);
+ m_isStartedHosting = false;
- discoveryManager = RCSDiscoveryManager::getInstance();
+ RHLock lock(m_mutexForList);
+ m_hostingObjects.clear();
}
-void ResourceHosting::requestMulticastDiscovery()
+void ResourceHosting::createDiscoveryListener()
{
- discoveryTask = discoveryManager->discoverResourceByType(
- RCSAddress::multicast(), OC_RSRVD_WELL_KNOWN_URI, HOSTING_RESOURSE_TYPE, pDiscoveryCB);
+ m_discoveryTask = RCSDiscoveryManager::getInstance()->discoverResourceByType(
+ RCSAddress::multicast(), OC_RSRVD_WELL_KNOWN_URI, HOSTING_RESOURSE_TYPE,
+ std::bind(&ResourceHosting::discoveryHandler, this,
+ std::placeholders::_1));
}
-void ResourceHosting::discoverHandler(RemoteObjectPtr remoteResource)
+void ResourceHosting::discoveryHandler(RemoteObjectPtr remoteResource)
{
- std::string discoverdUri = remoteResource->getUri();
+ auto discoverdUri = remoteResource->getUri();
if(discoverdUri.compare(
discoverdUri.size()-HOSTING_TAG_SIZE, HOSTING_TAG_SIZE, HOSTING_TAG) != 0)
{
return;
}
- HostingObjectPtr foundHostingObject = findRemoteResource(remoteResource);
- if(foundHostingObject == nullptr)
+ auto foundHostingObject = findRemoteResource(remoteResource);
+ if(foundHostingObject != nullptr) return;
+
+ try
{
- try
- {
- foundHostingObject = std::make_shared<HostingObject>();
- foundHostingObject->initializeHostingObject(remoteResource,
- std::bind(&ResourceHosting::destroyedHostingObject, this,
- HostingObjectWeakPtr(foundHostingObject)));
- hostingObjectList.push_back(foundHostingObject);
- }catch(const RCSInvalidParameterException &e)
- {
- OIC_HOSTING_LOG(DEBUG,
- "[ResourceHosting::discoverHandler]InvalidParameterException:%s", e.what());
- }
- }
-}
+ HostingObjectKey key = generateHostingObjectKey(remoteResource);
+ foundHostingObject = HostingObject::createHostingObject(remoteResource,
+ std::bind(&ResourceHosting::destroyedHostingObject, this, key));
-ResourceHosting::HostingObjectPtr ResourceHosting::findRemoteResource(
- RemoteObjectPtr remoteResource)
-{
- HostingObjectPtr retObject = nullptr;
+ RHLock lock(m_mutexForList);
+ m_hostingObjects.insert(std::make_pair(key, foundHostingObject));
- for(auto it : hostingObjectList)
+ }catch(const RCSException &e)
{
- RemoteObjectPtr inListPtr = it->getRemoteResource();
- if(inListPtr != nullptr && isSameRemoteResource(inListPtr, remoteResource))
- {
- retObject = it;
- }
+ OIC_HOSTING_LOG(DEBUG,
+ "[ResourceHosting::discoverHandler]InvalidParameterException:%s", e.what());
}
-
- return retObject;
}
-bool ResourceHosting::isSameRemoteResource(
- RemoteObjectPtr remoteResource_1, RemoteObjectPtr remoteResource_2)
+HostingObject::Ptr ResourceHosting::findRemoteResource(RemoteObjectPtr remoteResource)
{
- bool ret = false;
- if(remoteResource_1->getAddress() == remoteResource_2->getAddress() &&
- remoteResource_1->getUri() == remoteResource_2->getUri())
- {
- ret = true;
- }
- return ret;
+ RHLock lock(m_mutexForList);
+
+ auto iter = m_hostingObjects.find(generateHostingObjectKey(remoteResource));
+ if(iter != m_hostingObjects.end()) return iter->second;
+
+ return nullptr;
}
-void ResourceHosting::destroyedHostingObject(HostingObjectWeakPtr destroyedWeakPtr)
+void ResourceHosting::destroyedHostingObject(const HostingObjectKey & key)
{
- auto destroyedPtr = destroyedWeakPtr.lock();
- if (destroyedPtr) return;
-
- std::unique_lock<std::mutex> lock(mutexForList);
- hostingObjectList.remove(destroyedPtr);
+ RHLock lock(m_mutexForList);
+ m_hostingObjects.erase(key);
}
} /* namespace Service */
#ifndef RH_RESOURCEHOSTING_H_
#define RH_RESOURCEHOSTING_H_
-#include <cstdbool>
-#include <iostream>
+#include <atomic>
+#include <functional>
#include <list>
#include <memory>
-#include <functional>
-#include <string>
-#include <atomic>
+#include <mutex>
-#include "octypes.h"
-#include "RCSAddress.h"
-#include "PresenceSubscriber.h"
-#include "HostingObject.h"
-#include "PrimitiveResource.h"
#include "RCSDiscoveryManager.h"
+#include "RCSRemoteResourceObject.h"
+#include "HostingObject.h"
namespace OIC
{
namespace Service
{
-class RCSDiscoveryManager;
class ResourceHosting
{
private:
- typedef std::shared_ptr<HostingObject> HostingObjectPtr;
- typedef std::weak_ptr<HostingObject> HostingObjectWeakPtr;
-
- typedef std::shared_ptr<RCSRemoteResourceObject> RemoteObjectPtr;
- typedef std::shared_ptr<PrimitiveResource> PrimiteveResourcePtr;
+ typedef RCSRemoteResourceObject::Ptr RemoteObjectPtr;
+ typedef std::lock_guard<std::mutex> RHLock;
+ typedef std::string HostingObjectKey;
- typedef std::function<
- void(std::shared_ptr<RCSRemoteResourceObject>)> DiscoveryCallback;
- typedef std::function<void()> DestroyedCallback;
+ typedef std::function<void(RemoteObjectPtr)> DiscoveryCallback;
+ typedef HostingObject::DestroyedCallback DestroyedCallback;
public:
void startHosting();
ResourceHosting();
~ResourceHosting() = default;
- ResourceHosting(const ResourceHosting&) = delete;
ResourceHosting(ResourceHosting&&) = delete;
- ResourceHosting& operator=(const ResourceHosting&) const = delete;
- ResourceHosting& operator=(ResourceHosting&&) const = delete;
-
- static ResourceHosting * s_instance;
- static std::mutex s_mutexForCreation;
- std::mutex mutexForList;
-
- std::list<HostingObjectPtr> hostingObjectList;
-
- RCSDiscoveryManager * discoveryManager;
- std::unique_ptr<RCSDiscoveryManager::DiscoveryTask> discoveryTask;
-
- DiscoveryCallback pDiscoveryCB;
+ ResourceHosting(const ResourceHosting&) = delete;
+ ResourceHosting& operator=(ResourceHosting&&) = delete;
+ ResourceHosting& operator=(const ResourceHosting&) = delete;
- void initializeResourceHosting();
+ std::mutex m_mutexForList;
+ std::atomic_bool m_isStartedHosting;
- void requestMulticastDiscovery();
+ std::unordered_map<HostingObjectKey, HostingObject::Ptr> m_hostingObjects;
+ RCSDiscoveryManager::DiscoveryTask::Ptr m_discoveryTask;
- void discoverHandler(RemoteObjectPtr remoteResource);
+ void createDiscoveryListener();
+ void discoveryHandler(RemoteObjectPtr remoteResource);
- HostingObjectPtr findRemoteResource(RemoteObjectPtr remoteResource);
- bool isSameRemoteResource(RemoteObjectPtr remoteResource_1, RemoteObjectPtr remoteResource_2);
+ inline HostingObjectKey generateHostingObjectKey(std::string address, std::string uri)
+ {
+ return HostingObjectKey(address + uri);
+ }
+ inline HostingObjectKey generateHostingObjectKey(RemoteObjectPtr rResource)
+ {
+ return HostingObjectKey(rResource->getAddress() + rResource->getUri());
+ }
- void destroyedHostingObject(HostingObjectWeakPtr destroyedWeakPtr);
+ HostingObject::Ptr findRemoteResource(RemoteObjectPtr remoteResource);
+ void destroyedHostingObject(const HostingObjectKey & key);
};
} /* namespace Service */
namespace
{
+ std::string HOSTING_INTERFACETYPE = "oic.r.resourcehosting";
+ std::string TEST_ATT_KEY = "Temperature";
bool isDeleted = false;
- void onDestroy(std::weak_ptr<HostingObject> rPtr)
+ void onDestroy()
{
- HostingObject::Ptr ptr = rPtr.lock();
- if(ptr) ptr.reset();
isDeleted = true;
}
void onDiscoveryResource(RCSRemoteResourceObject::Ptr){ }
TEST_F(HostingObjectTest, startCachingAtInitialize)
{
- HostingObject::Ptr instance = std::make_shared<HostingObject>();
- instance->initializeHostingObject(
- remoteObject, std::bind(onDestroy, std::weak_ptr<HostingObject>(instance)));
+ HostingObject::Ptr instance = HostingObject::createHostingObject(
+ remoteObject, &onDestroy);
EXPECT_TRUE(remoteObject->isCaching());
}
TEST_F(HostingObjectTest, startMonitoringAtInitialize)
{
- HostingObject::Ptr instance = std::make_shared<HostingObject>();
- instance->initializeHostingObject(
- remoteObject, std::bind(onDestroy, std::weak_ptr<HostingObject>(instance)));
+ HostingObject::Ptr instance = HostingObject::createHostingObject(
+ remoteObject, onDestroy);
ASSERT_TRUE(remoteObject->isMonitoring());
}
TEST_F(HostingObjectTest, getRemoteResourceisValid)
{
- HostingObject::Ptr instance = std::make_shared<HostingObject>();
- instance->initializeHostingObject(
- remoteObject, std::bind(onDestroy, std::weak_ptr<HostingObject>(instance)));
+ HostingObject::Ptr instance = HostingObject::createHostingObject(
+ remoteObject, onDestroy);
ASSERT_EQ(remoteObject->getUri(), instance->getRemoteResource()->getUri());
}
TEST_F(HostingObjectTest, createMirroredServer)
{
- int waitForResponse = 1000;
+ int waitForResponse = 2000;
std::string uri = "";
- HostingObject::Ptr instance = std::make_shared<HostingObject>();
- instance->initializeHostingObject(
- remoteObject, std::bind(onDestroy, std::weak_ptr<HostingObject>(instance)));
- std::this_thread::sleep_for(std::chrono::milliseconds {waitForResponse});
+ HostingObject::Ptr instance = HostingObject::createHostingObject(remoteObject, onDestroy);
+ waitForCondition();
+ testObject->getResourceServer()->
+ setAttribute(TEST_ATT_KEY, RCSResourceAttributes::Value(int(10)));
std::unique_ptr<RCSDiscoveryManager::DiscoveryTask> discoveryTask = { };
});
discoveryTask = RCSDiscoveryManager::getInstance()->discoverResourceByType(
- RCSAddress::multicast(), "resource.hosting", onDiscoveryResource);
+ RCSAddress::multicast(), HOSTING_INTERFACETYPE, onDiscoveryResource);
waitForCondition(waitForResponse);
EXPECT_EQ(testObject->getHostedServerUri(), uri);
TEST_F(HostingObjectTest, UpdateCachedDataWhenChangedOriginResource)
{
int waitForResponse = 1000;
- HostingObject::Ptr instance = std::make_shared<HostingObject>();
- instance->initializeHostingObject(
- remoteObject, std::bind(onDestroy, std::weak_ptr<HostingObject>(instance)));
+ HostingObject::Ptr instance = HostingObject::createHostingObject(remoteObject, onDestroy);
std::this_thread::sleep_for(std::chrono::milliseconds {waitForResponse});
std::unique_ptr<RCSDiscoveryManager::DiscoveryTask> discoveryTask = { };
});
discoveryTask = RCSDiscoveryManager::getInstance()->discoverResourceByType(
- RCSAddress::multicast(), "resource.hosting", onDiscoveryResource);
+ RCSAddress::multicast(), HOSTING_INTERFACETYPE, onDiscoveryResource);
waitForCondition(waitForResponse);
RCSResourceAttributes::Value result = { };
mocks.OnCallFunc(onUpdatedCache).Do(
[this, &result](const RCSResourceAttributes & att)
{
- result = att.at("Temperature");
+ result = att.at(TEST_ATT_KEY);
notifyCondition();
});
std::this_thread::sleep_for(std::chrono::milliseconds {waitForResponse});
RCSResourceAttributes::Value settingValue = 10;
- testObject->getResourceServer()->setAttribute("Temperature", settingValue);
+ testObject->getResourceServer()->setAttribute(TEST_ATT_KEY, settingValue);
waitForCondition(waitForResponse);
EXPECT_EQ(result.toString(), settingValue.toString());
namespace
{
- void setRequestCB(const RCSResourceAttributes &, RCSResourceAttributes &) { }
+ void setRequestCB(const RCSResourceAttributes &, const RCSResourceAttributes & ) { }
}
class RequestObjectTest : public TestWithMock
RequestObject::Ptr instance = std::make_shared<RequestObject>(setRequestCB);
mocks.ExpectCallFunc(setRequestCB).Do(
- [this, &isCalled](const RCSResourceAttributes &, RCSResourceAttributes &)
+ [this, &isCalled](const RCSResourceAttributes &, const RCSResourceAttributes &)
{
isCalled = true;
notifyCondition();
});
RCSResourceAttributes att;
- instance->invokeRequest(remoteObject, RequestObject::RequestMethod::Setter, att);
+ instance->invokeRequest(remoteObject, RequestObject::RequestMethod::Set, att);
waitForCondition();
MULTICASTURI("/oic/res"),
HOSTED_RESOURCEURI("/a/TempHumSensor"),
RESOURCEURI("/a/TempHumSensor/hosting"),
- RESOURCETYPE("resource.hosting"),
+ RESOURCETYPE("oic.r.resourcehosting"),
RESOURCEINTERFACE("oic.if.baseline"),
ATTR_KEY("Temperature"),
ATTR_VALUE(0)
});
discoveryTask = RCSDiscoveryManager::getInstance()->discoverResourceByType(
- RCSAddress::multicast(), "resource.hosting", onDiscoveryResource);
+ RCSAddress::multicast(), "oic.r.resourcehosting", onDiscoveryResource);
waitForCondition(2000);
std::string mirroredUri = { testObject->getHostedServerUri() };
hosting_test_env.PrependUnique(CPPPATH = [ src_dir + '/extlibs/hippomocks-master',
gtest_dir + '/include'])
-hosting_test_env.AppendUnique(CPPPATH = ['../'])
-hosting_test_env.AppendUnique(CPPPATH = ['../../../resource-encapsulation/include'])
-hosting_test_env.AppendUnique(CPPPATH = ['../../../resource-encapsulation/src/common/primitiveResource/include'])
-hosting_test_env.AppendUnique(CPPPATH = ['../../../resource-encapsulation/src/common/utils/include'])
+hosting_test_env.AppendUnique(CPPPATH = ['../src'])
+hosting_test_env.AppendUnique(CPPPATH = ['../../resource-encapsulation/include'])
+hosting_test_env.AppendUnique(CPPPATH = ['../../resource-encapsulation/src/common/primitiveResource/include'])
+hosting_test_env.AppendUnique(CPPPATH = ['../../resource-encapsulation/src/common/utils/include'])
######################################################################
# Build Test
######################################################################
# from tools.scons.RunTest import *
# run_test(hosting_test_env,
# '',
-# 'service/notification-manager/NotificationManager/src/unittest/hosting_test')
\ No newline at end of file
+# 'service/resource-hosting/unittest/hosting_test')
\ No newline at end of file
projects / contrib / iotivity.git / commitdiff