#include "RCSResourceObject.h"
-#include <string>
#include <functional>
#include <vector>
#include "ResourceAttributesConverter.h"
#include "ResourceAttributesUtils.h"
#include "RCSRequest.h"
+#include "RCSRepresentation.h"
+#include "InterfaceHandler.h"
#include "logger.h"
#include "OCPlatform.h"
return base & ~target;
}
- template <typename RESPONSE>
- OCEntityHandlerResult sendResponse(RCSResourceObject& resource,
- const std::shared_ptr< OC::OCResourceRequest >& ocRequest, RESPONSE&& response)
+ OCEntityHandlerResult sendResponse(const std::shared_ptr< OC::OCResourceRequest >& ocRequest,
+ const std::shared_ptr< OC::OCResourceResponse >& ocResponse)
{
- auto ocResponse = response.getHandler()->buildResponse(resource);
ocResponse->setRequestHandle(ocRequest->getRequestHandle());
ocResponse->setResourceHandle(ocRequest->getResourceHandle());
}
catch (const OC::OCException& e)
{
- OC_LOG_V(WARNING, LOG_TAG, "Error (%s)", e.what());
+ OIC_LOG_V(WARNING, LOG_TAG, "Error (%s)", e.what());
}
return OC_EH_ERROR;
template< typename HANDLER, typename RESPONSE =
typename std::decay<HANDLER>::type::result_type >
- RESPONSE invokeHandler(RCSResourceAttributes& attrs,
+ RESPONSE invokeHandler(const RCSResourceObject::Ptr& resObj, RCSResourceAttributes& attrs,
const std::shared_ptr< OC::OCResourceRequest >& ocRequest,
std::shared_ptr< HANDLER > handler)
{
if (handler)
{
- return (*handler)(RCSRequest{ ocRequest->getResourceUri() }, attrs);
+ return (*handler)(RCSRequest{ resObj, ocRequest }, attrs);
}
return RESPONSE::defaultAction();
(bool, RCSResourceObject::AutoNotifyPolicy) const;
std::function<void()> createAutoNotifyInvoker(AutoNotifyFunc autoNotifyFunc,
- const RCSResourceObject& resourceObject, const RCSResourceAttributes& resourceAttributes,
+ const RCSResourceObject& resourceObject,
+ const RCSResourceAttributes& resourceAttributes,
RCSResourceObject::AutoNotifyPolicy autoNotifyPolicy)
{
if(autoNotifyPolicy == RCSResourceObject::AutoNotifyPolicy::UPDATED)
}
return {};
}
-} // unnamed namespace
+} // unnamed namespace
namespace OIC
{
RCSResourceObject::Builder::Builder(const std::string& uri, const std::string& type,
const std::string& interface) :
m_uri{ uri },
- m_type{ type },
- m_interface{ interface },
+ m_types{ type },
+ m_interfaces{ interface },
+ m_defaultInterface { BASELINE_INTERFACE },
m_properties{ OC_DISCOVERABLE | OC_OBSERVABLE },
m_resourceAttributes{ }
{
}
+ RCSResourceObject::Builder& RCSResourceObject::Builder::addInterface(
+ const std::string& interface)
+ {
+ return addInterface(std::string{ interface });
+ }
+
+ RCSResourceObject::Builder& RCSResourceObject::Builder::addInterface(
+ std::string&& interface)
+ {
+ m_interfaces.push_back(std::move(interface));
+ return *this;
+ }
+
+ RCSResourceObject::Builder& RCSResourceObject::Builder::addType(const std::string& type)
+ {
+ return addType(std::string{ type });
+ }
+
+ RCSResourceObject::Builder& RCSResourceObject::Builder::addType(std::string&& type)
+ {
+ m_types.push_back(std::move(type));
+ return *this;
+ }
+
+ RCSResourceObject::Builder& RCSResourceObject::Builder::setDefaultInterface(
+ std::string interface)
+ {
+ if (std::find(m_interfaces.begin(), m_interfaces.end(), interface) ==
+ m_interfaces.end())
+ {
+ throw RCSBadRequestException{"The interface should be added, first."};
+ }
+
+ m_defaultInterface = std::move(interface);
+
+ return *this;
+ }
+
RCSResourceObject::Builder& RCSResourceObject::Builder::setDiscoverable(
bool discoverable)
{
return *this;
}
+ RCSResourceObject::Builder& RCSResourceObject::Builder::setSecureFlag(
+ bool secureFlag)
+ {
+ m_properties = ::makePropertyFlags(m_properties, OC_SECURE, secureFlag);
+ return *this;
+ }
RCSResourceObject::Builder& RCSResourceObject::Builder::setAttributes(
const RCSResourceAttributes& attrs)
{
OCResourceHandle handle{ nullptr };
RCSResourceObject::Ptr server {
- new RCSResourceObject{ m_properties, std::move(m_resourceAttributes) } };
+ new RCSResourceObject{ m_uri, m_properties, std::move(m_resourceAttributes) } };
OC::EntityHandler entityHandler{ std::bind(&RCSResourceObject::entityHandler,
- server.get(), std::placeholders::_1) };
+ std::weak_ptr< RCSResourceObject >{ server }, std::placeholders::_1) };
typedef OCStackResult (*RegisterResource)(OCResourceHandle&, std::string&,
const std::string&, const std::string&, OC::EntityHandler, uint8_t);
invokeOCFunc(static_cast<RegisterResource>(OC::OCPlatform::registerResource),
- handle, m_uri, m_type, m_interface, entityHandler, m_properties);
+ handle, m_uri, m_types[0], m_interfaces[0], entityHandler, m_properties);
+
+ std::for_each(m_interfaces.begin() + 1, m_interfaces.end(),
+ [&handle](const std::string& interfaceName){
+ invokeOCFunc(OC::OCPlatform::bindInterfaceToResource, handle, interfaceName);
+ });
+
+ std::for_each(m_types.begin() + 1, m_types.end(),
+ [&handle](const std::string& typeName){
+ invokeOCFunc(OC::OCPlatform::bindTypeToResource, handle, typeName);
+ });
- server->m_resourceHandle = handle;
+ server->init(handle, m_interfaces, m_types, m_defaultInterface);
return server;
}
- RCSResourceObject::RCSResourceObject(uint8_t properties, RCSResourceAttributes&& attrs) :
- m_properties { properties },
+ RCSResourceObject::RCSResourceObject(const std::string& uri,
+ uint8_t properties, RCSResourceAttributes&& attrs) :
+ m_properties{ properties },
+ m_uri{ uri },
+ m_interfaces{ },
+ m_types{ },
+ m_defaultInterface{ },
m_resourceHandle{ },
m_resourceAttributes{ std::move(attrs) },
m_getRequestHandler{ },
m_setRequestHandler{ },
- m_autoNotifyPolicy { AutoNotifyPolicy::UPDATED },
- m_setRequestHandlerPolicy { SetRequestHandlerPolicy::NEVER },
+ m_autoNotifyPolicy{ AutoNotifyPolicy::UPDATED },
+ m_setRequestHandlerPolicy{ SetRequestHandlerPolicy::NEVER },
m_attributeUpdatedListeners{ },
m_lockOwner{ },
m_mutex{ },
m_lockOwner.reset(new AtomicThreadId);
}
+ void RCSResourceObject::init(OCResourceHandle handle,
+ const std::vector< std::string >& interfaces,
+ const std::vector< std::string >& types,
+ const std::string& defaultInterface)
+ {
+ m_resourceHandle = handle;
+ m_interfaces = interfaces;
+ m_types = types;
+ m_defaultInterface = defaultInterface;
+
+ for (const auto& itf : interfaces)
+ {
+ m_interfaceHandlers.insert({ itf, getDefaultInterfaceHandler(itf,
+ m_defaultInterface) });
+ }
+ }
+
RCSResourceObject::~RCSResourceObject()
{
if (m_resourceHandle)
}
catch (...)
{
- OC_LOG(WARNING, LOG_TAG, "Failed to unregister resource.");
+ OIC_LOG(WARNING, LOG_TAG, "Failed to unregister resource.");
}
}
}
return m_setRequestHandlerPolicy;
}
+ void RCSResourceObject::bindResource(const RCSResourceObject::Ptr& resource)
+ {
+ if (!resource || resource.get() == this)
+ {
+ throw RCSInvalidParameterException("The resource is invalid!");
+ }
+
+ invokeOCFunc(OC::OCPlatform::bindResource,
+ m_resourceHandle, resource->m_resourceHandle);
+
+ std::lock_guard< std:: mutex > lock{ m_mutexForBoundResources };
+ m_boundResources.push_back(resource);
+ }
+
+ void RCSResourceObject::unbindResource(const RCSResourceObject::Ptr& resource)
+ {
+ if (!resource || resource.get() == this)
+ {
+ throw RCSInvalidParameterException("The resource is invalid!");
+ }
+
+ invokeOCFunc(OC::OCPlatform::unbindResource,
+ m_resourceHandle, resource->m_resourceHandle);
+
+ std::lock_guard< std:: mutex > lock{ m_mutexForBoundResources };
+ m_boundResources.erase(std::find(m_boundResources.begin(), m_boundResources.end(),
+ resource));
+ }
+
+ std::vector< RCSResourceObject::Ptr > RCSResourceObject::getBoundResources() const
+ {
+ std::lock_guard< std:: mutex > lock{ m_mutexForBoundResources };
+ return m_boundResources;
+ }
+
+ std::string RCSResourceObject::getUri() const
+ {
+ return m_uri;
+ }
+
+ std::string RCSResourceObject::getDefaultInterface() const
+ {
+ return m_defaultInterface;
+ }
+
+ std::vector< std::string > RCSResourceObject::getInterfaces() const
+ {
+ return m_interfaces;
+ }
+
+ std::vector< std::string > RCSResourceObject::getTypes() const
+ {
+ return m_types;
+ }
+
+ RCSRepresentation RCSResourceObject::toRepresentation() const
+ {
+ WeakGuard lock{*this};
+ return RCSRepresentation{ m_uri, m_interfaces, m_types, m_resourceAttributes };
+ }
+
void RCSResourceObject::autoNotify(bool isAttributesChanged) const
{
autoNotify(isAttributesChanged, m_autoNotifyPolicy);
}
OCEntityHandlerResult RCSResourceObject::entityHandler(
+ const std::weak_ptr< RCSResourceObject >& weakRes,
const std::shared_ptr< OC::OCResourceRequest >& request)
{
- OC_LOG(WARNING, LOG_TAG, "entityHandler");
+ auto resource = weakRes.lock();
+
+ if (!resource) return OC_EH_ERROR;
+
+ OIC_LOG(WARNING, LOG_TAG, "entityHandler");
if (!request)
{
return OC_EH_ERROR;
{
if (request->getRequestHandlerFlag() & OC::RequestHandlerFlag::RequestFlag)
{
- return handleRequest(request);
+ return resource->handleRequest(request);
}
if (request->getRequestHandlerFlag() & OC::RequestHandlerFlag::ObserverFlag)
{
- return handleObserve(request);
+ return resource->handleObserve(request);
}
}
catch (const std::exception& e)
{
- OC_LOG_V(WARNING, LOG_TAG, "Failed to handle request : %s", e.what());
+ OIC_LOG_V(WARNING, LOG_TAG, "Failed to handle request : %s", e.what());
throw;
}
catch (...)
{
- OC_LOG(WARNING, LOG_TAG, "Failed to handle request.");
+ OIC_LOG(WARNING, LOG_TAG, "Failed to handle request.");
throw;
}
{
assert(request != nullptr);
+ RCSRequest rcsRequest{ shared_from_this(), request };
+
+ if (rcsRequest.getInterface() != "" && m_interfaceHandlers.find(
+ rcsRequest.getInterface()) == m_interfaceHandlers.end())
+ {
+ return OC_EH_ERROR;
+ }
+
if (request->getRequestType() == "GET")
{
- return handleRequestGet(request);
+ return handleRequestGet(rcsRequest);
}
- if (request->getRequestType() == "PUT")
+ if (request->getRequestType() == "POST")
{
- return handleRequestSet(request);
+ return handleRequestSet(rcsRequest);
}
return OC_EH_ERROR;
}
OCEntityHandlerResult RCSResourceObject::handleRequestGet(
- const std::shared_ptr< OC::OCResourceRequest >& request)
+ const RCSRequest& request)
{
- assert(request != nullptr);
+ if (!findInterfaceHandler(request.getInterface()).isGetSupported())
+ {
+ return OC_EH_ERROR;
+ }
+
+ auto attrs = getAttributesFromOCRequest(request.getOCRequest());
+ auto response = invokeHandler(shared_from_this(), attrs, request.getOCRequest(),
+ m_getRequestHandler);
+
+ if (response.isSeparate()) return OC_EH_SLOW;
- auto attrs = getAttributesFromOCRequest(request);
- return sendResponse(*this, request, invokeHandler(attrs, request, m_getRequestHandler));
+ return sendResponse(request, response,
+ findInterfaceHandler(request.getInterface()).getGetResponseBuilder());
}
- bool RCSResourceObject::applyAcceptanceMethod(const RCSSetResponse& response,
- const RCSResourceAttributes& requstAttrs)
+ RCSResourceAttributes RCSResourceObject::applyAcceptanceMethod(
+ const RCSSetResponse& response, const RCSResourceAttributes& requestAttrs)
{
auto requestHandler = response.getHandler();
assert(requestHandler != nullptr);
+ RCSResourceAttributes result;
+
auto replaced = requestHandler->applyAcceptanceMethod(response.getAcceptanceMethod(),
- *this, requstAttrs);
+ *this, requestAttrs);
- OC_LOG_V(WARNING, LOG_TAG, "replaced num %zu", replaced.size());
+ OIC_LOG_V(WARNING, LOG_TAG, "replaced num %zu", replaced.size());
for (const auto& attrKeyValPair : replaced)
{
std::shared_ptr< AttributeUpdatedListener > foundListener;
if (foundListener)
{
- (*foundListener)(attrKeyValPair.second, requstAttrs.at(attrKeyValPair.first));
+ (*foundListener)(attrKeyValPair.second, requestAttrs.at(attrKeyValPair.first));
}
+
+ result[attrKeyValPair.first] = attrKeyValPair.second;
}
- return !replaced.empty();
+ return result;
}
OCEntityHandlerResult RCSResourceObject::handleRequestSet(
- const std::shared_ptr< OC::OCResourceRequest >& request)
+ const RCSRequest& request)
{
- assert(request != nullptr);
-
- auto attrs = getAttributesFromOCRequest(request);
- auto response = invokeHandler(attrs, request, m_setRequestHandler);
-
- auto attrsChanged = applyAcceptanceMethod(response, attrs);
-
- try
+ if (!findInterfaceHandler(request.getInterface()).isSetSupported())
{
- autoNotify(attrsChanged, m_autoNotifyPolicy);
- return sendResponse(*this, request, response);
- } catch (const RCSPlatformException& e) {
- OC_LOG_V(ERROR, LOG_TAG, "Error : %s ", e.what());
return OC_EH_ERROR;
}
+
+ auto attrs = getAttributesFromOCRequest(request.getOCRequest());
+
+ auto response = invokeHandler(shared_from_this(), attrs, request.getOCRequest(),
+ m_setRequestHandler);
+
+ if (response.isSeparate()) return OC_EH_SLOW;
+
+ auto replaced = applyAcceptanceMethod(response, attrs);
+
+ autoNotify(!replaced.empty(), m_autoNotifyPolicy);
+
+ return sendResponse(request, response,
+ findInterfaceHandler(request.getInterface()).getSetResponseBuilder());
}
OCEntityHandlerResult RCSResourceObject::handleObserve(
return OC_EH_OK;
}
+ InterfaceHandler RCSResourceObject::findInterfaceHandler(
+ const std::string& interfaceName) const
+ {
+ auto it = m_interfaceHandlers.find(interfaceName);
+
+ if (it != m_interfaceHandlers.end()) return it->second;
+
+ assert(m_interfaceHandlers.find(m_defaultInterface) != m_interfaceHandlers.end());
+
+ return m_interfaceHandlers.find(m_defaultInterface)->second;
+ }
+
+ template <typename RESPONSE, typename RESPONSE_BUILDER>
+ OCEntityHandlerResult RCSResourceObject::sendResponse(
+ const RCSRequest& request, const RESPONSE& response,
+ const RESPONSE_BUILDER& resBuilder)
+ {
+ auto reqHandler = response.getHandler();
+ auto ocResponse = std::make_shared< OC::OCResourceResponse >();
+
+ ocResponse->setResponseResult(OC_EH_OK);
+ ocResponse->setErrorCode(reqHandler->getErrorCode());
+
+ if (reqHandler->hasCustomRepresentation())
+ {
+ ocResponse->setResourceRepresentation(reqHandler->getRepresentation());
+ }
+ else
+ {
+ ocResponse->setResourceRepresentation(
+ RCSRepresentation::toOCRepresentation(
+ resBuilder(request, *this)));
+ }
+
+ return ::sendResponse(request.getOCRequest(), ocResponse);
+ }
+
+
RCSResourceObject::LockGuard::LockGuard(const RCSResourceObject::Ptr ptr) :
m_resourceObject(*ptr),
m_autoNotifyPolicy{ ptr->getAutoNotifyPolicy() },
projects / platform / upstream / iotivity.git / blobdiff