1. Applied code conventions.
2. Initialized variable when it was declared.
3. Added mutex unlock operation when consumer service is terminated.
4. Added enum class instead constant values at consumer Test code.
5. Changed enum class to NSSelector from NSAccessPolicy.
Change-Id: Icbcdb6f45bfdf41902d25c4ba5515d7318ea330a
Signed-off-by: KIM JungYong <jyong2.kim@samsung.com>
Reviewed-on: https://gerrit.iotivity.org/gerrit/9751
Tested-by: jenkins-iotivity <jenkins-iotivity@opendaylight.org>
Reviewed-by: Uze Choi <uzchoi@samsung.com>
int main(void)
{
bool isExit = false;
- pthread_t OCThread;
+ pthread_t OCThread = NULL;
printf("start Iotivity\n");
if (OCInit1(OC_CLIENT, OC_DEFAULT_FLAGS, OC_DEFAULT_FLAGS) != OC_STACK_OK)
printf("start notification consumer service\n");
while (!isExit)
{
- int num;
- char dummy;
+ int num = 0;
+ char dummy = '\0';
printf("1. Start Consumer\n");
printf("2. Stop Consumer\n");
NS_DISCOVER_CLOUD
} NSConsumerDiscoverType;
+typedef enum
+{
+ NS_SELECTION_CONSUMER = 0,
+ NS_SELECTION_PROVIDER = 1
+} NSSelector;
+
typedef struct NSProviderConnectionInfo
{
OCDevAddr * addr;
char * messageUri;
char * syncUri;
- NSAccessPolicy accessPolicy;
+ NSSelector accessPolicy;
NSProviderConnectionInfo * connection;
}
char * msgUri = OICStrdup(provider_internal->messageUri);
+ NS_VERIFY_NOT_NULL(msgUri, NS_ERROR);
char * syncUri = OICStrdup(provider_internal->syncUri);
+ NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(syncUri, NS_ERROR, NSOICFree(msgUri));
OCConnectivityType type = CT_DEFAULT;
if (connections->addr->adapter == OC_ADAPTER_TCP)
if (connections->isCloudConnection == true)
{
msgUri = NSGetCloudUri(provider_internal->providerId, msgUri);
+ NS_VERIFY_NOT_NULL(msgUri, NS_ERROR);
syncUri = NSGetCloudUri(provider_internal->providerId, syncUri);
+ NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(syncUri, NS_ERROR, NSOICFree(msgUri));
}
}
return OC_STACK_KEEP_TRANSACTION;
}
-void NSRemoveProviderObj(NSProvider_internal * provider)
-{
- NSOICFree(provider->messageUri);
- NSOICFree(provider->syncUri);
-
- NSRemoveConnections(provider->connection);
- NSOICFree(provider);
-}
-
OCStackApplicationResult NSIntrospectProvider(
void * ctx, OCDoHandle handle, OCClientResponse * clientResponse)
{
NS_LOG(DEBUG, "build NSTask");
NSTask * task = NSMakeTask(TASK_CONSUMER_PROVIDER_DISCOVERED, (void *) newProvider);
- NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(task, NS_ERROR, NSRemoveProviderObj(newProvider));
+ NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(task, NS_ERROR, NSRemoveProvider(newProvider));
NSConsumerPushEvent(task);
NSOICFree(providerId);
newProvider->messageUri = messageUri;
newProvider->syncUri = syncUri;
- newProvider->accessPolicy = (NSAccessPolicy)accepter;
+ newProvider->accessPolicy = (NSSelector)accepter;
newProvider->connection = connection;
return newProvider;
NS_LOG(DEBUG, "provider's connection is updated.");
}
- if (provider->accessPolicy == NS_ACCESS_DENY && isSubscribing == false)
+ if (provider->accessPolicy == NS_SELECTION_CONSUMER && isSubscribing == false)
{
NS_LOG(DEBUG, "accepter is NS_ACCEPTER_CONSUMER, Callback to user");
NSDiscoveredProvider((NSProvider *) provider);
if (provider->connection->next == NULL)
{
+ NS_LOG(DEBUG, "call back to user");
NSSubscriptionAccepted((NSProvider *) provider);
}
}
NSConsumerThread * handle = NULL;
NSConsumerQueue * queue = NULL;
- uint8_t uuid[UUID_SIZE];
- char uuidString[UUID_STRING_SIZE];
- OCGenerateUuid(uuid);
- OCConvertUuidToString(uuid, uuidString);
+ uint8_t uuid[UUID_SIZE] = {0,};
+ char uuidString[UUID_STRING_SIZE] = {0,};
+ OCRandomUuidResult randomRet = OCGenerateUuid(uuid);
+ NS_VERIFY_NOT_NULL(randomRet == RAND_UUID_OK ? (void *) 1 : NULL, NS_ERROR);
+ randomRet = OCConvertUuidToString(uuid, uuidString);
+ NS_VERIFY_NOT_NULL(randomRet == RAND_UUID_OK ? (void *) 1 : NULL, NS_ERROR);
+
NSSetConsumerId(uuidString);
NS_LOG_V(DEBUG, "Consumer ID : %s", *NSGetConsumerId());
{
switch (task->taskType)
{
- case TASK_EVENT_CONNECTED:
- case TASK_EVENT_CONNECTED_TCP:
- case TASK_CONSUMER_REQ_DISCOVER:
- {
- NSConsumerDiscoveryTaskProcessing(task);
- break;
- }
- case TASK_CONSUMER_REQ_SUBSCRIBE:
- case TASK_SEND_SYNCINFO:
- {
- NSConsumerCommunicationTaskProcessing(task);
- break;
- }
- case TASK_CONSUMER_REQ_SUBSCRIBE_CANCEL:
- {
- NSProvider_internal * data = NSCopyProvider((NSProvider_internal *)task->taskData);
- NS_VERIFY_NOT_NULL_V(data);
- NSTask * conTask = NSMakeTask(TASK_CONSUMER_REQ_SUBSCRIBE_CANCEL, data);
- NS_VERIFY_NOT_NULL_V(conTask);
- NSConsumerCommunicationTaskProcessing(task);
- NSConsumerInternalTaskProcessing(conTask);
- break;
- }
- case TASK_RECV_SYNCINFO:
- case TASK_CONSUMER_RECV_MESSAGE:
- case TASK_CONSUMER_PROVIDER_DISCOVERED:
- case TASK_CONSUMER_RECV_SUBSCRIBE_CONFIRMED:
- case TASK_MAKE_SYNCINFO:
- {
- NSConsumerInternalTaskProcessing(task);
- break;
- }
- default:
- NS_LOG(ERROR, "Unknown type of task");
- break;
+ case TASK_EVENT_CONNECTED:
+ case TASK_EVENT_CONNECTED_TCP:
+ case TASK_CONSUMER_REQ_DISCOVER:
+ {
+ NSConsumerDiscoveryTaskProcessing(task);
+ break;
+ }
+ case TASK_CONSUMER_REQ_SUBSCRIBE:
+ case TASK_SEND_SYNCINFO:
+ {
+ NSConsumerCommunicationTaskProcessing(task);
+ break;
+ }
+ case TASK_CONSUMER_REQ_SUBSCRIBE_CANCEL:
+ {
+ NSProvider_internal * data = NSCopyProvider((NSProvider_internal *)task->taskData);
+ NS_VERIFY_NOT_NULL_V(data);
+ NSTask * conTask = NSMakeTask(TASK_CONSUMER_REQ_SUBSCRIBE_CANCEL, data);
+ NS_VERIFY_NOT_NULL_V(conTask);
+ NSConsumerCommunicationTaskProcessing(task);
+ NSConsumerInternalTaskProcessing(conTask);
+ break;
+ }
+ case TASK_RECV_SYNCINFO:
+ case TASK_CONSUMER_RECV_MESSAGE:
+ case TASK_CONSUMER_PROVIDER_DISCOVERED:
+ case TASK_CONSUMER_RECV_SUBSCRIBE_CONFIRMED:
+ case TASK_MAKE_SYNCINFO:
+ {
+ NSConsumerInternalTaskProcessing(task);
+ break;
+ }
+ default:
+ {
+ NS_LOG(ERROR, "Unknown type of task");
+ break;
+ }
}
}
pthread_mutex_destroy(&(handle->mutex));
pthread_mutexattr_destroy(&(handle->mutex_attr));
+
+ pthread_mutex_unlock(&g_create_mutex);
}
pthread_mutex_t * NSGetCacheMutex()
{
- static pthread_mutex_t NSCacheMutex;
- return & NSCacheMutex;
-}
+ static pthread_mutex_t * g_NSCacheMutex = NULL;
+ if (g_NSCacheMutex == NULL)
+ {
+ g_NSCacheMutex = (pthread_mutex_t *) OICMalloc(sizeof(pthread_mutex_t));
+ NS_VERIFY_NOT_NULL(g_NSCacheMutex, NULL);
-void NSSetCacheMutex(pthread_mutex_t mutex)
-{
- *(NSGetCacheMutex()) = mutex;
+ pthread_mutex_init(g_NSCacheMutex, NULL);
+ }
+ return g_NSCacheMutex;
}
NSCacheList * NSStorageCreate()
{
- pthread_mutex_t * mutex = (pthread_mutex_t *) OICMalloc(sizeof(pthread_mutex_t));
- NS_VERIFY_NOT_NULL(mutex, NULL);
-
- pthread_mutex_init(mutex, NULL);
- NSSetCacheMutex(*mutex);
-
+ pthread_mutex_t * mutex = NSGetCacheMutex();
pthread_mutex_lock(mutex);
NSCacheList * newList = (NSCacheList *) OICMalloc(sizeof(NSCacheList));
if (del == list->head)
{
if (del == list->tail)
+ {
list->tail = del->next;
+ }
+
list->head = del->next;
if (type == NS_CONSUMER_CACHE_MESSAGE)
if (NSConsumerCompareIdCacheData(type, del->data, delId))
{
if (del == list->tail)
+ {
list->tail = prev;
+ }
prev->next = del->next;
if (type == NS_CONSUMER_CACHE_MESSAGE)
NSResult NSConsumerCacheWriteProvider(NSCacheList * list, NSCacheElement * newObj)
{
- pthread_mutex_t * mutex = NSGetCacheMutex();
+ NS_VERIFY_NOT_NULL(list, NS_ERROR);
+ NS_VERIFY_NOT_NULL(newObj, NS_ERROR);
- pthread_mutex_lock(mutex);
+ pthread_mutex_t * mutex = NSGetCacheMutex();
NS_LOG (DEBUG, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!1");
NSProvider_internal * prov = (NSProvider_internal *)newObj->data;
NS_LOG_V (DEBUG, "%s", prov->providerId);
NS_LOG (DEBUG, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!1");
- if (!newObj)
- {
- pthread_mutex_unlock(mutex);
- NS_LOG (ERROR, "Failed to Write Provider Cache");
- return NS_ERROR;
- }
-
NSProvider_internal * newProvObj = (NSProvider_internal *) newObj->data;
- pthread_mutex_unlock(mutex);
NSCacheElement * it = NSStorageRead(list, newProvObj->providerId);
pthread_mutex_lock(mutex);
}
NSCacheElement * obj = (NSCacheElement *) OICMalloc(sizeof(NSCacheElement));
- if (!obj)
- {
- NS_LOG(ERROR, "Fail to Create New Object");
- pthread_mutex_unlock(mutex);
+ NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(obj, NS_ERROR, pthread_mutex_unlock(mutex));
- return NS_ERROR;
- }
NS_LOG_V(DEBUG, "New Object address : %s:%d", newProvObj->connection->addr->addr, newProvObj->connection->addr->port);
obj->data = (void *) NSCopyProvider(newProvObj);
std::condition_variable responseCon;
std::mutex mutexForCondition;
+ enum class NSSelector
+ {
+ NS_SELECTION_CONSUMER = 0,
+ NS_SELECTION_PROVIDER = 1
+ };
+
}
class TestWithMock: public testing::Test
std::cout << __func__ << std::endl;
}
- static void foundResourceEmpty(std::shared_ptr< OC::OCResource >)
+ static void NSFoundResourceEmpty(std::shared_ptr< OC::OCResource >)
{
std::cout << __func__ << std::endl;
}
- static void SubscriptionAcceptedCallback(NSProvider *)
+ static void NSSubscriptionAcceptedCallback(NSProvider *)
{
std::cout << __func__ << std::endl;
}
{
NSConsumerConfig cfg;
cfg.discoverCb = NSProviderDiscoveredCallbackEmpty;
- cfg.acceptedCb = SubscriptionAcceptedCallback;
+ cfg.acceptedCb = NSSubscriptionAcceptedCallback;
cfg.messageCb = NSNotificationReceivedCallbackEmpty;
cfg.syncInfoCb = NSSyncCallbackEmpty;
EXPECT_EQ(NS_OK, NSStartConsumer(cfg));
NSConsumerConfig cfg;
cfg.discoverCb = NSProviderDiscoveredCallbackEmpty;
- cfg.acceptedCb = SubscriptionAcceptedCallback;
+ cfg.acceptedCb = NSSubscriptionAcceptedCallback;
cfg.messageCb = NSNotificationReceivedCallbackEmpty;
cfg.syncInfoCb = NSSyncCallbackEmpty;
NSStartConsumer(cfg);
- g_providerSimul.setAccepter(1);
+ g_providerSimul.setAccepter((int)NSSelector::NS_SELECTION_CONSUMER);
g_providerSimul.createNotificationResource();
std::unique_lock< std::mutex > lock{ mutexForCondition };
TEST_F(NotificationConsumerTest, DiscoverProviderWithNonAccepterWhenStartedConsumerAfter)
{
- g_providerSimul.setAccepter(1);
+ g_providerSimul.setAccepter((int)NSSelector::NS_SELECTION_CONSUMER);
g_providerSimul.createNotificationResource();
{
std::unique_lock< std::mutex > lock{ mutexForCondition };
NSConsumerConfig cfg;
cfg.discoverCb = NSProviderDiscoveredCallbackEmpty;
- cfg.acceptedCb = SubscriptionAcceptedCallback;
+ cfg.acceptedCb = NSSubscriptionAcceptedCallback;
cfg.messageCb = NSNotificationReceivedCallbackEmpty;
cfg.syncInfoCb = NSSyncCallbackEmpty;
NSStartConsumer(cfg);
TEST_F(NotificationConsumerTest, DiscoverProviderWithNonAccepterWhenRescan)
{
- g_providerSimul.setAccepter(1);
+ g_providerSimul.setAccepter((int)NSSelector::NS_SELECTION_CONSUMER);
mocks.ExpectCallFunc(NSProviderDiscoveredCallbackEmpty).Do(
[this](NSProvider * provider)
{
TEST_F(NotificationConsumerTest, ExpectSubscribeSuccess)
{
- mocks.ExpectCallFunc(SubscriptionAcceptedCallback).Do(
- [](NSProvider * )
- {
- std::cout << "Income Accepted subscription : " << std::endl;
- });
+// mocks.ExpectCallFunc(NSSubscriptionAcceptedCallback).Do(
+// [](NSProvider * )
+// {
+// std::cout << "Income Accepted subscription : " << std::endl;
+// });
NSResult ret = NSSubscribe(g_provider);
std::unique_lock< std::mutex > lock{ mutexForCondition };
std::string title = "title";
std::string msg = "msg";
- g_providerSimul.setAccepter(0);
+ g_providerSimul.setAccepter((int)NSSelector::NS_SELECTION_PROVIDER);
NSConsumerConfig cfg;
cfg.discoverCb = NSProviderDiscoveredCallbackEmpty;
- cfg.acceptedCb = SubscriptionAcceptedCallback;
+ cfg.acceptedCb = NSSubscriptionAcceptedCallback;
cfg.messageCb = NSNotificationReceivedCallbackEmpty;
cfg.syncInfoCb = NSSyncCallbackEmpty;
NSStartConsumer(cfg);
projects / contrib / iotivity.git / commitdiff