service/notification/src/consumer/NSConsumerInternalTaskController.c

   1 //******************************************************************
   2 //
   3 // Copyright 2016 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 "NSConstants.h"
  22 #include "NSConsumerCommon.h"
  23 #include "NSConsumerInternalTaskController.h"
  24 #include "NSStructs.h"
  25
  26 #include "oic_malloc.h"
  27 #include "oic_string.h"
  28
  29 NSCacheList ** NSGetMessageCacheList()
  30 {
  31     static NSCacheList * messageCache = NULL;
  32     return & messageCache;
  33 }
  34
  35 void NSSetMessageCacheList(NSCacheList * cache)
  36 {
  37     *(NSGetMessageCacheList()) = cache;
  38 }
  39
  40 NSCacheList ** NSGetProviderCacheList()
  41 {
  42     static NSCacheList * providerCache = NULL;
  43     return & providerCache;
  44 }
  45
  46 void NSSetProviderCacheList(NSCacheList * cache)
  47 {
  48     *(NSGetProviderCacheList()) = cache;
  49 }
  50
  51 void NSDestroyMessageCacheList()
  52 {
  53     NSCacheList * cache = *(NSGetMessageCacheList());
  54     if (cache)
  55     {
  56         NSStorageDestroy(cache);
  57     }
  58
  59     NSSetMessageCacheList(NULL);
  60 }
  61
  62 void NSDestroyProviderCacheList()
  63 {
  64     NSCacheList * cache = *(NSGetProviderCacheList());
  65     if (cache)
  66     {
  67         NSStorageDestroy(cache);
  68     }
  69
  70     NSSetProviderCacheList(NULL);
  71 }
  72
  73 NSMessage * NSMessageCacheFind(const char * messageId)
  74 {
  75     NS_VERIFY_NOT_NULL(messageId, NULL);
  76
  77     NSCacheList * MessageCache = *(NSGetMessageCacheList());
  78     if (!MessageCache)
  79     {
  80         NS_LOG(DEBUG, "Message Cache Init");
  81         MessageCache = NSStorageCreate();
  82         NS_VERIFY_NOT_NULL(MessageCache, NULL);
  83
  84         MessageCache->cacheType = NS_CONSUMER_CACHE_MESSAGE;
  85         NSSetMessageCacheList(MessageCache);
  86     }
  87
  88     NSCacheElement * cacheElement = NSStorageRead(MessageCache, messageId);
  89     NS_VERIFY_NOT_NULL(cacheElement, NULL);
  90
  91     return NSCopyMessage(((NSStoreMessage *) cacheElement->data)->msg);
  92 }
  93
  94 NSProvider_internal * NSProviderCacheFind(const char * providerId)
  95 {
  96     NS_VERIFY_NOT_NULL(providerId, NULL);
  97
  98     NSCacheList * ProviderCache = *(NSGetProviderCacheList());
  99     if (!ProviderCache)
 100     {
 101         NS_LOG(DEBUG, "Provider Cache Init");
 102         ProviderCache = NSStorageCreate();
 103         NS_VERIFY_NOT_NULL(ProviderCache, NULL);
 104
 105         ProviderCache->cacheType = NS_CONSUMER_CACHE_PROVIDER;
 106         NSSetProviderCacheList(ProviderCache);
 107     }
 108
 109     NSCacheElement * cacheElement = NSStorageRead(ProviderCache, providerId);
 110     NS_VERIFY_NOT_NULL(cacheElement, NULL);
 111
 112     return NSCopyProvider((NSProvider_internal *) cacheElement->data);
 113 }
 114
 115 void NSRemoveCacheElementMessage(NSCacheElement * obj)
 116 {
 117     NSRemoveMessage(((NSStoreMessage *)obj->data)->msg);
 118     NSOICFree(obj->data);
 119     NSOICFree(obj);
 120 }
 121
 122 NSResult NSMessageCacheUpdate(NSMessage * msg, NSSyncType type)
 123 {
 124     NS_VERIFY_NOT_NULL(msg, NS_ERROR);
 125
 126     NSCacheList * MessageCache = *(NSGetMessageCacheList());
 127     if (!MessageCache)
 128     {
 129         NS_LOG(DEBUG, "Message Cache Init");
 130         MessageCache = NSStorageCreate();
 131         NS_VERIFY_NOT_NULL(MessageCache, NS_ERROR);
 132
 133         MessageCache->cacheType = NS_CONSUMER_CACHE_MESSAGE;
 134         NSSetMessageCacheList(MessageCache);
 135     }
 136
 137     NSStoreMessage * sMsg = (NSStoreMessage *)OICMalloc(sizeof(NSStoreMessage));
 138     NS_VERIFY_NOT_NULL(sMsg, NS_ERROR);
 139
 140     NSCacheElement * obj = (NSCacheElement *)OICMalloc(sizeof(NSCacheElement));
 141     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(obj, NS_ERROR, NSOICFree(sMsg));
 142
 143     sMsg->status = type;
 144     sMsg->msg = NSCopyMessage(msg);
 145
 146     obj->data = (NSCacheData *) sMsg;
 147     obj->next = NULL;
 148
 149     NS_LOG(DEBUG, "try to write to storage");
 150     NSResult ret = NSStorageWrite(MessageCache, obj);
 151     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(ret == NS_OK ? (void *) 1 : NULL,
 152             NS_ERROR, NSRemoveCacheElementMessage(obj));
 153
 154     NSRemoveCacheElementMessage(obj);
 155
 156     NS_LOG(DEBUG, "Update message done");
 157     return NS_OK;
 158 }
 159
 160 NSResult NSProviderCacheUpdate(NSProvider_internal * provider)
 161 {
 162     NSCacheList * ProviderCache = *(NSGetProviderCacheList());
 163     if (!ProviderCache)
 164     {
 165         NS_LOG(DEBUG, "Provider Cache Init");
 166         ProviderCache = NSStorageCreate();
 167         NS_VERIFY_NOT_NULL(ProviderCache, NS_ERROR);
 168
 169         ProviderCache->cacheType = NS_CONSUMER_CACHE_PROVIDER;
 170         NSSetProviderCacheList(ProviderCache);
 171     }
 172
 173     NS_VERIFY_NOT_NULL(provider, NS_ERROR);
 174
 175     NSCacheElement * obj = (NSCacheElement *)OICMalloc(sizeof(NSCacheElement));
 176     NS_VERIFY_NOT_NULL(obj, NS_ERROR);
 177
 178     obj->data = (NSCacheData *) provider;
 179     obj->next = NULL;
 180
 181     NS_LOG(DEBUG, "try to write to storage");
 182     NSResult ret = NSStorageWrite(ProviderCache, obj);
 183     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(ret == NS_OK ? (void *) 1 : NULL,
 184             NS_ERROR, NSOICFree(obj));
 185
 186     return NS_OK;
 187 }
 188
 189 void NSCancelAllSubscription()
 190 {
 191     NSCacheList * ProviderCache = *(NSGetProviderCacheList());
 192     if (!ProviderCache)
 193     {
 194         NS_LOG(DEBUG, "Provider Cache Init");
 195         ProviderCache = NSStorageCreate();
 196         NS_VERIFY_NOT_NULL_V(ProviderCache);
 197
 198         ProviderCache->cacheType = NS_CONSUMER_CACHE_PROVIDER;
 199         NSSetProviderCacheList(ProviderCache);
 200     }
 201
 202     NSCacheElement * obj = NULL;
 203     while ((obj = NSPopProviderCacheList(ProviderCache)))
 204     {
 205         NS_LOG(DEBUG, "build NSTask");
 206         NSTask * task = NSMakeTask(TASK_CONSUMER_REQ_SUBSCRIBE_CANCEL, (void *) obj->data);
 207         NS_VERIFY_NOT_NULL_V(task);
 208
 209         NSConsumerPushEvent(task);
 210     }
 211 }
 212
 213 void NSConsumerHandleProviderDiscovered(NSProvider_internal * provider)
 214 {
 215     NS_VERIFY_NOT_NULL_V(provider);
 216
 217     bool isAdded = true;
 218     bool isSubscribing = false;
 219     NSProvider_internal * providerCacheData = NSProviderCacheFind(provider->providerId);
 220
 221     if (providerCacheData == NULL)
 222     {
 223         isAdded = false;
 224     }
 225     else
 226     {
 227         providerCacheData->accessPolicy = provider->accessPolicy;
 228         NSProviderConnectionInfo * infos = providerCacheData->connection;
 229         OCTransportAdapter newAdapter = provider->connection->addr->adapter;
 230         while (infos)
 231         {
 232             isSubscribing |= infos->isSubscribing;
 233             if (infos->addr->adapter == newAdapter && infos->isSubscribing == true)
 234             {
 235                 NS_LOG_V(DEBUG, "This provider already discovered : %s:%d",
 236                          infos->addr->addr, infos->addr->port);
 237                 NS_LOG_V(DEBUG, "Subscription : %d", infos->isSubscribing);
 238                 return;
 239             }
 240             infos = infos->next;
 241         }
 242     }
 243
 244     NSResult ret = NSProviderCacheUpdate(provider);
 245     NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
 246
 247     if (isAdded == false)
 248     {
 249         NS_LOG(DEBUG, "New provider is discovered");
 250     }
 251     else
 252     {
 253         provider = providerCacheData;
 254         NS_LOG(DEBUG, "provider's connection is updated.");
 255     }
 256
 257     if (provider->accessPolicy == NS_SELECTION_CONSUMER && isSubscribing == false)
 258     {
 259         NS_LOG(DEBUG, "accepter is NS_ACCEPTER_CONSUMER, Callback to user");
 260         NSDiscoveredProvider((NSProvider *) provider);
 261     }
 262     else
 263     {
 264         NS_LOG(DEBUG, "accepter is NS_ACCEPTER_PROVIDER, request subscribe");
 265         NSProvider_internal * subProvider = NSCopyProvider(provider);
 266         NSTask * task = NSMakeTask(TASK_CONSUMER_REQ_SUBSCRIBE, (void *) subProvider);
 267         NS_VERIFY_NOT_NULL_V(task);
 268
 269         NSConsumerPushEvent(task);
 270     }
 271
 272     NSRemoveProvider(providerCacheData);
 273 }
 274
 275 void NSConsumerHandleProviderDeleted(NSProvider_internal * provider)
 276 {
 277     NS_VERIFY_NOT_NULL_V(provider);
 278
 279     NSCacheList * providerCache = *(NSGetProviderCacheList());
 280     NS_VERIFY_NOT_NULL_V(providerCache);
 281
 282     NSResult ret = NSStorageDelete(providerCache, provider->providerId);
 283     NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *)1 : NULL);
 284 }
 285
 286 void NSConsumerHandleRecvSubscriptionConfirmed(NSMessage * msg)
 287 {
 288     NS_VERIFY_NOT_NULL_V(msg);
 289
 290     NS_LOG_V(DEBUG, "confirmed by : %s", msg->providerId);
 291     NSProvider_internal * provider = NSProviderCacheFind(msg->providerId);
 292     NS_VERIFY_NOT_NULL_V(provider);
 293
 294     if (provider->connection->next == NULL)
 295     {
 296         NS_LOG(DEBUG, "call back to user");
 297         NSSubscriptionAccepted((NSProvider *) provider);
 298     }
 299 }
 300
 301 void NSConsumerHandleRecvMessage(NSMessage * msg)
 302 {
 303     NS_VERIFY_NOT_NULL_V(msg);
 304
 305     NSResult ret = NSMessageCacheUpdate(msg, NS_SYNC_UNREAD);
 306     NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
 307
 308     NSMessagePost((NSMessage *) msg);
 309 }
 310
 311 void NSConsumerHandleRecvSyncInfo(NSSyncInfo * sync)
 312 {
 313     NS_VERIFY_NOT_NULL_V(sync);
 314
 315     char msgId[NS_DEVICE_ID_LENGTH] = { 0, };
 316     snprintf(msgId, NS_DEVICE_ID_LENGTH, "%lld", (long long int)sync->messageId);
 317
 318     NSMessage * msg = NSMessageCacheFind(msgId);
 319     NS_VERIFY_NOT_NULL_V(msg);
 320
 321     NSResult ret = NSMessageCacheUpdate(msg, sync->state);
 322     NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
 323     NSRemoveMessage(msg);
 324
 325     NSNotificationSync(sync);
 326 }
 327
 328 void NSConsumerHandleMakeSyncInfo(NSSyncInfo * sync)
 329 {
 330     NS_VERIFY_NOT_NULL_V(sync);
 331
 332     NSProvider_internal * provider = NSProviderCacheFind(sync->providerId);
 333     NS_VERIFY_NOT_NULL_V (provider);
 334
 335     NSProviderConnectionInfo * connections = NSCopyProviderConnections(provider->connection);
 336     NS_VERIFY_NOT_NULL_V (connections);
 337
 338     NSSyncInfo_internal * syncInfo = (NSSyncInfo_internal *)OICMalloc(sizeof(NSSyncInfo_internal));
 339     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(syncInfo, NSRemoveConnections(connections));
 340
 341     OICStrcpy(syncInfo->providerId, sizeof(char) * NS_DEVICE_ID_LENGTH, sync->providerId);
 342     syncInfo->messageId = sync->messageId;
 343     syncInfo->state = sync->state;
 344     syncInfo->connection = connections;
 345
 346     NSTask * syncTask = NSMakeTask(TASK_SEND_SYNCINFO, (void *) syncInfo);
 347     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(syncTask, NSOICFree(syncInfo));
 348
 349     NSConsumerPushEvent(syncTask);
 350 }
 351
 352 void NSConsumerHandleGetTopicUri(NSMessage * msg)
 353 {
 354     NS_VERIFY_NOT_NULL_V(msg);
 355
 356     NSProvider_internal * provider = NSProviderCacheFind(msg->providerId);
 357     NS_VERIFY_NOT_NULL_V(provider);
 358
 359     NSTask * topicTask = NSMakeTask(TASK_CONSUMER_REQ_TOPIC_LIST, (void *) provider);
 360     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(topicTask, NSRemoveProvider(provider));
 361
 362     NSConsumerPushEvent(topicTask);
 363 }
 364
 365 void NSConsumerHandleRecvTopicList(NSProvider_internal * provider)
 366 {
 367     NS_VERIFY_NOT_NULL_V(provider);
 368
 369     NSResult ret = NSProviderCacheUpdate(provider);
 370     NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
 371
 372     // call the callback function when consumer is an accepter
 373     if (provider->connection->next == NULL)
 374     {
 375         NS_LOG(DEBUG, "call back to user");
 376         NSProviderChanged((NSProvider *) provider, (NSResponse) NS_TOPIC);
 377     }
 378 }
 379
 380 void NSConsumerInternalTaskProcessing(NSTask * task)
 381 {
 382     NS_VERIFY_NOT_NULL_V(task);
 383
 384     NS_LOG_V(DEBUG, "Receive Event : %d", (int)task->taskType);
 385     switch (task->taskType)
 386     {
 387         case TASK_CONSUMER_RECV_SUBSCRIBE_CONFIRMED:
 388         {
 389             NS_LOG(DEBUG, "Receive Subscribe confirm from provider.");
 390             NSConsumerHandleRecvSubscriptionConfirmed((NSMessage *)task->taskData);
 391             NSRemoveMessage((NSMessage *)task->taskData);
 392             break;
 393         }
 394         case TASK_CONSUMER_RECV_MESSAGE:
 395         {
 396             NS_LOG(DEBUG, "Receive New Notification");
 397             NSConsumerHandleRecvMessage((NSMessage *)task->taskData);
 398             NSRemoveMessage((NSMessage *)task->taskData);
 399             break;
 400         }
 401         case TASK_CONSUMER_PROVIDER_DISCOVERED:
 402         {
 403             NS_LOG(DEBUG, "Receive New Provider is discovered.");
 404             NSConsumerHandleProviderDiscovered((NSProvider_internal *)task->taskData);
 405             NSRemoveProvider((NSProvider_internal *)task->taskData);
 406             break;
 407         }
 408         case TASK_RECV_SYNCINFO:
 409         {
 410             NS_LOG(DEBUG, "Receive SyncInfo.");
 411             NSConsumerHandleRecvSyncInfo((NSSyncInfo *)task->taskData);
 412             NSOICFree(task->taskData);
 413             break;
 414         }
 415         case TASK_MAKE_SYNCINFO:
 416         {
 417             NS_LOG(DEBUG, "Make SyncInfo, get Provider's Addr");
 418             NSConsumerHandleMakeSyncInfo((NSSyncInfo *)task->taskData);
 419             NSOICFree(task->taskData);
 420             break;
 421         }
 422         case TASK_CONSUMER_REQ_TOPIC_URI:
 423         {
 424             NS_LOG(DEBUG, "Request Topic Uri");
 425             NSConsumerHandleGetTopicUri((NSMessage *)task->taskData);
 426             NSRemoveMessage((NSMessage *)task->taskData);
 427             break;
 428         }
 429         case TASK_CONSUMER_RECV_TOPIC_LIST:
 430         {
 431             NS_LOG(DEBUG, "Receive Topic List");
 432             NSConsumerHandleRecvTopicList((NSProvider_internal *)task->taskData);
 433             NSRemoveProvider((NSProvider_internal *)task->taskData);
 434             break;
 435         }
 436         case TASK_CONSUMER_REQ_SUBSCRIBE_CANCEL:
 437         {
 438             NS_LOG(DEBUG, "Make Subscribe cancel from provider.");
 439             NSConsumerHandleProviderDeleted((NSProvider_internal *)task->taskData);
 440             NSRemoveProvider((NSProvider_internal *)task->taskData);
 441             break;
 442         }
 443         default :
 444         {
 445             NS_LOG(ERROR, "Unknown TASK Type");
 446             return ;
 447         }
 448     }
 449     NSOICFree(task);
 450 }