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_consumer * 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((NSMessage_consumer *) cacheElement->data);
  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
 116 NSResult NSMessageCacheUpdate(NSMessage_consumer * msg, NSSyncType type)
 117 {
 118     NSCacheList * MessageCache = *(NSGetMessageCacheList());
 119     if (!MessageCache)
 120     {
 121         NS_LOG(DEBUG, "Message Cache Init");
 122         MessageCache = NSStorageCreate();
 123         NS_VERIFY_NOT_NULL(MessageCache, NS_ERROR);
 124
 125         MessageCache->cacheType = NS_CONSUMER_CACHE_MESSAGE;
 126         NSSetMessageCacheList(MessageCache);
 127     }
 128
 129     NS_VERIFY_NOT_NULL(msg, NS_ERROR);
 130
 131     msg->type = type;
 132
 133     NSCacheElement * obj = (NSCacheElement *)OICMalloc(sizeof(NSCacheElement));
 134     NS_VERIFY_NOT_NULL(obj, NS_ERROR);
 135
 136     obj->data = (NSCacheData *) msg;
 137     obj->next = NULL;
 138
 139     NS_LOG(DEBUG, "try to write to storage");
 140     NSResult ret = NSStorageWrite(MessageCache, obj);
 141     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(ret == NS_OK ? (void *) 1 : NULL,
 142             NS_ERROR, NSOICFree(obj));
 143
 144     return NS_OK;
 145 }
 146
 147 NSResult NSProviderCacheUpdate(NSProvider_internal * provider)
 148 {
 149     NSCacheList * ProviderCache = *(NSGetProviderCacheList());
 150     if (!ProviderCache)
 151     {
 152         NS_LOG(DEBUG, "Provider Cache Init");
 153         ProviderCache = NSStorageCreate();
 154         NS_VERIFY_NOT_NULL(ProviderCache, NS_ERROR);
 155
 156         ProviderCache->cacheType = NS_CONSUMER_CACHE_PROVIDER;
 157         NSSetProviderCacheList(ProviderCache);
 158     }
 159
 160     NS_VERIFY_NOT_NULL(provider, NS_ERROR);
 161
 162     NSCacheElement * obj = (NSCacheElement *)OICMalloc(sizeof(NSCacheElement));
 163     NS_VERIFY_NOT_NULL(obj, NS_ERROR);
 164
 165     obj->data = (NSCacheData *) provider;
 166     obj->next = NULL;
 167
 168     NS_LOG(DEBUG, "try to write to storage");
 169     NSResult ret = NSStorageWrite(ProviderCache, obj);
 170     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(ret == NS_OK ? (void *) 1 : NULL,
 171             NS_ERROR, NSOICFree(obj));
 172
 173     return NS_OK;
 174 }
 175
 176 void NSCancelAllSubscription()
 177 {
 178     NSCacheList * ProviderCache = *(NSGetProviderCacheList());
 179     if (!ProviderCache)
 180     {
 181         NS_LOG(DEBUG, "Provider Cache Init");
 182         ProviderCache = NSStorageCreate();
 183         NS_VERIFY_NOT_NULL_V(ProviderCache);
 184
 185         ProviderCache->cacheType = NS_CONSUMER_CACHE_PROVIDER;
 186         NSSetProviderCacheList(ProviderCache);
 187     }
 188
 189     NSCacheElement * obj = NULL;
 190     while ((obj = NSPopProviderCacheList(ProviderCache)))
 191     {
 192         NS_LOG(DEBUG, "build NSTask");
 193         NSTask * task = NSMakeTask(TASK_CONSUMER_REQ_SUBSCRIBE_CANCEL, (void *) obj->data);
 194         NS_VERIFY_NOT_NULL_V(task);
 195
 196         NSConsumerPushEvent(task);
 197     }
 198 }
 199
 200 void NSConsumerHandleProviderDiscovered(NSProvider_internal * provider)
 201 {
 202     NS_VERIFY_NOT_NULL_V(provider);
 203
 204     bool isAdded = true;
 205     bool isSubscribing = false;
 206     NSProvider_internal * providerCacheData = NSProviderCacheFind(provider->providerId);
 207
 208     if (providerCacheData == NULL)
 209     {
 210         isAdded = false;
 211     }
 212     else
 213     {
 214         providerCacheData->accessPolicy = provider->accessPolicy;
 215         NSProviderConnectionInfo * infos = providerCacheData->connection;
 216         OCTransportAdapter newAdapter = provider->connection->addr->adapter;
 217         while (infos)
 218         {
 219             isSubscribing |= infos->isSubscribing;
 220             if (infos->addr->adapter == newAdapter && infos->isSubscribing == true)
 221             {
 222                 NS_LOG_V(DEBUG, "This provider already discovered : %s:%d",
 223                          infos->addr->addr, infos->addr->port);
 224                 NS_LOG_V(DEBUG, "Subscription : %d", infos->isSubscribing);
 225                 return;
 226             }
 227             infos = infos->next;
 228         }
 229     }
 230
 231     NSResult ret = NSProviderCacheUpdate(provider);
 232     NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
 233
 234     if (isAdded == false)
 235     {
 236         NS_LOG(DEBUG, "New provider is discovered");
 237     }
 238     else
 239     {
 240         provider = providerCacheData;
 241         NS_LOG(DEBUG, "provider's connection is updated.");
 242     }
 243
 244     if (provider->accessPolicy == NS_ACCESS_DENY && isSubscribing == false)
 245     {
 246         NS_LOG(DEBUG, "accepter is NS_ACCEPTER_CONSUMER, Callback to user");
 247         NSDiscoveredProvider((NSProvider *) provider);
 248     }
 249     else
 250     {
 251         NS_LOG(DEBUG, "accepter is NS_ACCEPTER_PROVIDER, request subscribe");
 252         NSProvider_internal * subProvider = NSCopyProvider(provider);
 253         NSTask * task = NSMakeTask(TASK_CONSUMER_REQ_SUBSCRIBE, (void *) subProvider);
 254         NS_VERIFY_NOT_NULL_V(task);
 255
 256         NSConsumerPushEvent(task);
 257     }
 258
 259     NSRemoveProvider(providerCacheData);
 260 }
 261
 262 void NSConsumerHandleProviderDeleted(NSProvider_internal * provider)
 263 {
 264     NS_VERIFY_NOT_NULL_V(provider);
 265
 266     NSCacheList * providerCache = *(NSGetProviderCacheList());
 267     NS_VERIFY_NOT_NULL_V(providerCache);
 268
 269     NSResult ret = NSStorageDelete(providerCache, provider->providerId);
 270     NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *)1 : NULL);
 271 }
 272
 273 void NSConsumerHandleRecvSubscriptionConfirmed(NSMessage_consumer * msg)
 274 {
 275     NS_VERIFY_NOT_NULL_V(msg);
 276
 277     NS_LOG_V(DEBUG, "confirmed by : %s", msg->providerId);
 278     NSProvider_internal * provider = NSProviderCacheFind(msg->providerId);
 279     NS_VERIFY_NOT_NULL_V(provider);
 280
 281     if (provider->connection->next == NULL)
 282     {
 283         NSSubscriptionAccepted((NSProvider *) provider);
 284     }
 285 }
 286
 287 void NSConsumerHandleRecvMessage(NSMessage_consumer * msg)
 288 {
 289     NS_VERIFY_NOT_NULL_V(msg);
 290
 291     NSResult ret = NSMessageCacheUpdate(msg, NS_SYNC_UNREAD);
 292     NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
 293
 294     NSMessagePost((NSMessage *) msg);
 295 }
 296
 297 void NSConsumerHandleRecvSyncInfo(NSSyncInfo * sync)
 298 {
 299     NS_VERIFY_NOT_NULL_V(sync);
 300
 301     char msgId[NS_DEVICE_ID_LENGTH] = { 0, };
 302     snprintf(msgId, NS_DEVICE_ID_LENGTH, "%lld", (long long int)sync->messageId);
 303
 304     NSMessage_consumer * msg = NSMessageCacheFind(msgId);
 305     NS_VERIFY_NOT_NULL_V(msg);
 306
 307     NSResult ret = NSMessageCacheUpdate(msg, sync->state);
 308     NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
 309     NSRemoveMessage(msg);
 310
 311     NSNotificationSync(sync);
 312 }
 313
 314 void NSConsumerHandleMakeSyncInfo(NSSyncInfo * sync)
 315 {
 316     NS_VERIFY_NOT_NULL_V(sync);
 317
 318     NSProvider_internal * provider = NSProviderCacheFind(sync->providerId);
 319     NS_VERIFY_NOT_NULL_V (provider);
 320
 321     NSProviderConnectionInfo * connections = NSCopyProviderConnections(provider->connection);
 322     NS_VERIFY_NOT_NULL_V (connections);
 323
 324     NSSyncInfo_internal * syncInfo = (NSSyncInfo_internal *)OICMalloc(sizeof(NSSyncInfo_internal));
 325     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(syncInfo, NSRemoveConnections(connections));
 326
 327     OICStrcpy(syncInfo->providerId, sizeof(char) * NS_DEVICE_ID_LENGTH, sync->providerId);
 328     syncInfo->messageId = sync->messageId;
 329     syncInfo->state = sync->state;
 330     syncInfo->connection = connections;
 331
 332     NSTask * syncTask = NSMakeTask(TASK_SEND_SYNCINFO, (void *) syncInfo);
 333     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(syncTask, NSOICFree(syncInfo));
 334
 335     NSConsumerPushEvent(syncTask);
 336 }
 337
 338 void NSConsumerInternalTaskProcessing(NSTask * task)
 339 {
 340     NS_VERIFY_NOT_NULL_V(task);
 341
 342     NS_LOG_V(DEBUG, "Receive Event : %d", (int)task->taskType);
 343     switch (task->taskType)
 344     {
 345         case TASK_CONSUMER_RECV_SUBSCRIBE_CONFIRMED:
 346         {
 347             NS_LOG(DEBUG, "Receive Subscribe confirm from provider.");
 348             NSConsumerHandleRecvSubscriptionConfirmed((NSMessage_consumer *)task->taskData);
 349             NSRemoveMessage((NSMessage_consumer *)task->taskData);
 350             break;
 351         }
 352         case TASK_CONSUMER_RECV_MESSAGE:
 353         {
 354             NS_LOG(DEBUG, "Receive New Notification");
 355             NSConsumerHandleRecvMessage((NSMessage_consumer *)task->taskData);
 356             NSRemoveMessage((NSMessage_consumer *)task->taskData);
 357             break;
 358         }
 359         case TASK_CONSUMER_PROVIDER_DISCOVERED:
 360         {
 361             NS_LOG(DEBUG, "Receive New Provider is discovered.");
 362             NSConsumerHandleProviderDiscovered((NSProvider_internal *)task->taskData);
 363             NSRemoveProvider((NSProvider_internal *)task->taskData);
 364             break;
 365         }
 366         case TASK_RECV_SYNCINFO:
 367         {
 368             NS_LOG(DEBUG, "Receive SyncInfo.");
 369             NSConsumerHandleRecvSyncInfo((NSSyncInfo *)task->taskData);
 370             NSOICFree(task->taskData);
 371             break;
 372         }
 373         case TASK_MAKE_SYNCINFO:
 374         {
 375             NS_LOG(DEBUG, "Make SyncInfo, get Provider's Addr");
 376             NSConsumerHandleMakeSyncInfo((NSSyncInfo *)task->taskData);
 377             NSOICFree(task->taskData);
 378             break;
 379         }
 380         case TASK_CONSUMER_REQ_SUBSCRIBE_CANCEL:
 381         {
 382             NS_LOG(DEBUG, "Make Subscribe cancel from provider.");
 383             NSConsumerHandleProviderDeleted((NSProvider_internal *)task->taskData);
 384             NSRemoveProvider((NSProvider_internal *)task->taskData);
 385             break;
 386         }
 387         default :
 388         {
 389             NS_LOG(ERROR, "Unknown TASK Type");
 390             return ;
 391         }
 392     }
 393     NSOICFree(task);
 394 }