NSResult NSSetMessagePayload(NSMessage *msg, OCRepPayload** msgPayload)
{
    NS_LOG(DEBUG, "NSSetMessagePayload - IN");

    *msgPayload = msg->extraInfo != NULL ? msg->extraInfo : OCRepPayloadCreate();

    if (!*msgPayload)
    {
        NS_LOG(ERROR, "Failed to allocate payload");
        return NS_ERROR;
    }

    OCRepPayloadSetUri(*msgPayload, NS_COLLECTION_MESSAGE_URI);
    OCRepPayloadSetPropInt(*msgPayload, NS_ATTRIBUTE_MESSAGE_ID, msg->messageId);
    OCRepPayloadSetPropString(*msgPayload, NS_ATTRIBUTE_PROVIDER_ID, msg->providerId);

    NSDuplicateSetPropertyInt(msgPayload, NS_ATTRIBUTE_TYPE, msg->type);
    NSDuplicateSetPropertyInt(msgPayload, NS_ATTRIBUTE_TTL, msg->ttl);
    NSDuplicateSetPropertyString(msgPayload, NS_ATTRIBUTE_DATETIME, msg->dateTime);
    NSDuplicateSetPropertyString(msgPayload, NS_ATTRIBUTE_TITLE, msg->title);
    NSDuplicateSetPropertyString(msgPayload, NS_ATTRIBUTE_TEXT, msg->contentText);
    NSDuplicateSetPropertyString(msgPayload, NS_ATTRIBUTE_SOURCE, msg->sourceName);
    NSDuplicateSetPropertyString(msgPayload, NS_ATTRIBUTE_TOPIC_NAME, msg->topic);

    if (msg->mediaContents)
    {
        NSDuplicateSetPropertyString(msgPayload, NS_ATTRIBUTE_ICON_IMAGE,
                msg->mediaContents->iconImage);
    }

    NS_LOG(DEBUG, "NSSetMessagePayload - OUT");
    return NS_OK;
}
示例#2
0
 NSResult NSProviderService::EnableRemoteService(const std::string &serverAddress)
 {
     NS_LOG(DEBUG, "EnableRemoteService - IN");
     NSResult result = NSProviderEnableRemoteService(OICStrdup(serverAddress.c_str()));
     NS_LOG(DEBUG, "EnableRemoteService - OUT");
     return result;
 }
NSResult NSProviderCacheUpdate(NSProvider_internal * provider)
{
    NSCacheList * ProviderCache = *(NSGetProviderCacheList());
    if (!ProviderCache)
    {
        NS_LOG(DEBUG, "Provider Cache Init");
        ProviderCache = NSStorageCreate();
        NS_VERIFY_NOT_NULL(ProviderCache, NS_ERROR);

        ProviderCache->cacheType = NS_CONSUMER_CACHE_PROVIDER;
        NSSetProviderCacheList(ProviderCache);
    }

    NS_VERIFY_NOT_NULL(provider, NS_ERROR);

    NSCacheElement * obj = (NSCacheElement *)OICMalloc(sizeof(NSCacheElement));
    NS_VERIFY_NOT_NULL(obj, NS_ERROR);

    obj->data = (NSCacheData *) provider;
    obj->next = NULL;

    NS_LOG(DEBUG, "try to write to storage");
    NSResult ret = NSStorageWrite(ProviderCache, obj);
    NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(ret == NS_OK ? (void *) 1 : NULL,
            NS_ERROR, NSOICFree(obj));

    return NS_OK;
}
示例#4
0
NSResult NSRegisterResource()
{
    NS_LOG(DEBUG, "NSRegisterResource - IN");

    if (NSCreateResource(NS_COLLECTION_SYNC_URI) != NS_OK)
    {
        NS_LOG(ERROR, "Fail to register Sync Resource");
        return NS_ERROR;
    }

    if (NSCreateResource(NS_COLLECTION_MESSAGE_URI) != NS_OK)
    {
        NS_LOG(ERROR, "Fail to register Message Resource");
        return NS_ERROR;
    }

    if (NSCreateResource(NS_ROOT_URI) != NS_OK)
    {
        NS_LOG(ERROR, "Fail to register Notification Resource");
        return NS_ERROR;
    }

    NS_LOG(DEBUG, "NSRegisterResource - OUT");
    return NS_OK;
}
示例#5
0
NSResult NSPutMessageResource(NSMessage *msg, OCResourceHandle * handle)
{
    NS_LOG(DEBUG, "NSPutMessageResource - IN");

    if(msg != NULL)
    {
        NS_LOG(DEBUG, "NSMessage is valid");

        NotificationMessageResource.messageId = msg->messageId;
        OICStrcpy(NotificationMessageResource.providerId, UUID_STRING_SIZE, msg->providerId);
        NotificationMessageResource.type = msg->type;
        NotificationMessageResource.dateTime = msg->dateTime;
        NotificationMessageResource.ttl = msg->ttl;
        NotificationMessageResource.title = msg->title;
        NotificationMessageResource.contentText = msg->contentText;
        NotificationMessageResource.sourceName = msg->sourceName;
        NotificationMessageResource.mediaContents = msg->mediaContents;
    }
    else
    {
        NS_LOG(ERROR, "NSMessage is NULL");
    }

    *handle = NotificationMessageResource.handle;
    NS_LOG(DEBUG, "NSPutMessageResource - OUT");

    return NS_OK;
}
NSCacheElement * NSProviderStorageRead(NSCacheList * list, const char * findId)
{
    pthread_mutex_lock(&NSCacheMutex);

    NS_LOG(DEBUG, "NSCacheRead - IN");

    NSCacheElement * iter = list->head;
    NSCacheElement * next = NULL;
    NSCacheType type = list->cacheType;

    NS_LOG_V(INFO_PRIVATE, "Find ID - %s", findId);

    while (iter)
    {
        next = iter->next;

        if (NSProviderCompareIdCacheData(type, iter->data, findId))
        {
            NS_LOG(DEBUG, "Found in Cache");
            pthread_mutex_unlock(&NSCacheMutex);
            return iter;
        }

        iter = next;
    }

    NS_LOG(DEBUG, "Not found in Cache");
    NS_LOG(DEBUG, "NSCacheRead - OUT");
    pthread_mutex_unlock(&NSCacheMutex);

    return NULL;
}
示例#7
0
 NSResult NSProviderService::Stop()
 {
     NS_LOG(DEBUG, "Stop - IN");
     NSResult result = NSStopProvider();
     NS_LOG(DEBUG, "Stop - OUT");
     return result;
 }
示例#8
0
NSResult NSUnRegisterResource()
{
    NS_LOG(DEBUG, "NSUnRegisterResource - IN");

    if (OCDeleteResource(NotificationResource.handle) != OC_STACK_OK)
    {
        NS_LOG(ERROR, "Fail to Delete Notification Resource");
        return NS_ERROR;
    }

    if (OCDeleteResource(NotificationMessageResource.handle) != OC_STACK_OK)
    {
        NS_LOG(ERROR, "Fail to Delete Notification Message Resource");
        return NS_ERROR;
    }

    if (OCDeleteResource(NotificationSyncResource.handle) != OC_STACK_OK)
    {
        NS_LOG(ERROR, "Fail to Delete Notification Sync Resource");
        return NS_ERROR;
    }

    NotificationResource.handle = NULL;
    NotificationMessageResource.handle = NULL;
    NotificationSyncResource.handle = NULL;

    NS_LOG(DEBUG, "NSUnRegisterResource - OUT");
    return NS_OK;
}
示例#9
0
 void NSProviderService::SendSyncInfo(uint64_t messageId,
                                      NSSyncInfo::NSSyncType type)
 {
     NS_LOG(DEBUG, "SendSyncInfo - IN");
     NSProviderSendSyncInfo(messageId, (NSSyncType)type);
     NS_LOG(DEBUG, "SendSyncInfo - OUT");
     return;
 }
示例#10
0
 void onConsumerSubscribedCallback(::NSConsumer *consumer)
 {
     NS_LOG(DEBUG, "onConsumerSubscribedCallback - IN");
     NSConsumer *nsConsumer = new NSConsumer(consumer);
     if (NSProviderService::getInstance()->getProviderConfig().m_subscribeRequestCb != NULL)
         NSProviderService::getInstance()->getProviderConfig().m_subscribeRequestCb(nsConsumer);
     delete nsConsumer;
     NS_LOG(DEBUG, "onConsumerSubscribedCallback - OUT");
 }
示例#11
0
 void onMessageSynchronizedCallback(::NSSyncInfo *syncInfo)
 {
     NS_LOG(DEBUG, "onMessageSynchronizedCallback - IN");
     NSSyncInfo *nsSyncInfo = new NSSyncInfo(syncInfo);
     if (NSProviderService::getInstance()->getProviderConfig().m_syncInfoCb != NULL)
         NSProviderService::getInstance()->getProviderConfig().m_syncInfoCb(nsSyncInfo);
     delete nsSyncInfo;
     NS_LOG(DEBUG, "onMessageSynchronizedCallback - OUT");
 }
示例#12
0
 NSResult NSProviderService::SendMessage(NSMessage *msg)
 {
     NS_LOG(DEBUG, "SendMessage - IN");
     NSResult result = NS_ERROR;
     if (msg != nullptr)
         result = NSSendMessage(getNSMessage(msg));
     else
         NS_LOG(DEBUG, "Empty Message");
     NS_LOG(DEBUG, "SendMessage - OUT");
     return result;
 }
示例#13
0
        NSResult NSProviderService::Start(NSProviderService::NSAccessPolicy policy,
                                          NSProviderService::ProviderConfig config)
        {
            NS_LOG(DEBUG, "Start - IN");

            m_config = config;
            NSResult result = NSStartProvider((::NSAccessPolicy)policy, onConsumerSubscribedCallback,
                                              onMessageSynchronizedCallback);
            NS_LOG(DEBUG, "Start - OUT");
            return result;
        }
示例#14
0
NSResult NSPutSyncResource(NSSyncInfo *sync, OCResourceHandle * handle)
{
    NS_LOG(DEBUG, "NSPutSyncResource - IN");

    (void) sync;

    *handle = NotificationSyncResource.handle;

    NS_LOG(DEBUG, "NSPutSyncResource - OUT");
    return NS_OK;
}
示例#15
0
NSResult NSPutNotificationResource(int accepter, OCResourceHandle * handle)
{
    NS_LOG(DEBUG, "NSPutNotificationResource - IN");

    NotificationResource.accepter = accepter;
    NotificationResource.message_uri = NS_COLLECTION_MESSAGE_URI;
    NotificationResource.sync_uri = NS_COLLECTION_SYNC_URI;

    *handle = NotificationResource.handle;

    NS_LOG(DEBUG, "NSPutNotificationResource - OUT");
    return NS_OK;
}
示例#16
0
bool NSStartScheduler()
{
    int i = 0;

    for (i = 0; i < THREAD_COUNT; i++)
    {
        pthread_mutex_lock(&NSMutex[i]);

        switch (i)
        {
            case CALLBACK_RESPONSE_SCHEDULER:
            {
                NS_LOG(DEBUG, "CASE RESPONSE_SCHEDULER :");
                pthread_create(&NSThread[i], NULL, NSCallbackResponseSchedule, NULL);
            }
                break;

            case DISCOVERY_SCHEDULER:
            {
                NS_LOG(DEBUG, "CASE DISCOVERY_SCHEDULER :");
                pthread_create(&NSThread[i], NULL, NSDiscoverySchedule, NULL);
            }
                break;

            case SUBSCRIPTION_SCHEDULER:
            {
                NS_LOG(DEBUG, "CASE SUBSCRIPTION_SCHEDULER :");
                pthread_create(&NSThread[i], NULL, NSSubScriptionSchedule, NULL);
            }
                break;

            case NOTIFICATION_SCHEDULER:
            {
                NS_LOG(DEBUG, "CASE NOTIFICATION_SCHEDULER :");
                pthread_create(&NSThread[i], NULL, NSNotificationSchedule, NULL);
            }
                break;

            default:
                break;

        }

        NSHeadMsg[i] = NSTailMsg[i] = NULL;

        pthread_mutex_unlock(&NSMutex[i]);

    }

    return true;
}
示例#17
0
NSTopicLL * NSProviderGetTopicsCacheData(NSCacheList * regTopicList)
{
    NS_LOG(DEBUG, "NSProviderGetTopicsCache - IN");
    pthread_mutex_lock(&NSCacheMutex);

    NSCacheElement * iter = regTopicList->head;

    if (!iter)
    {
        pthread_mutex_unlock(&NSCacheMutex);
        return NULL;
    }

    NSTopicLL * iterTopic = NULL;
    NSTopicLL * newTopic = NULL;
    NSTopicLL * topics = NULL;

    while (iter)
    {
        NSCacheTopicData * curr = (NSCacheTopicData *) iter->data;
        newTopic = (NSTopicLL *) OICMalloc(sizeof(NSTopicLL));

        if (!newTopic)
        {
            pthread_mutex_unlock(&NSCacheMutex);
            return NULL;
        }

        newTopic->state = curr->state;
        newTopic->next = NULL;
        newTopic->topicName = OICStrdup(curr->topicName);

        if (!topics)
        {
            iterTopic = topics = newTopic;
        }
        else
        {
            iterTopic->next = newTopic;
            iterTopic = newTopic;
        }

        iter = iter->next;
    }

    pthread_mutex_unlock(&NSCacheMutex);
    NS_LOG(DEBUG, "NSProviderGetTopicsCache - OUT");

    return topics;
}
示例#18
0
NSTopicLL * NSProviderGetConsumerTopicsCacheData(NSCacheList * regTopicList,
        NSCacheList * conTopicList, const char * consumerId)
{
    NS_LOG(DEBUG, "NSProviderGetConsumerTopicsCacheData - IN");

    pthread_mutex_lock(&NSCacheMutex);
    NSTopicLL * topics = NSProviderGetTopicsCacheData(regTopicList);

    if (!topics)
    {
        pthread_mutex_unlock(&NSCacheMutex);
        return NULL;
    }

    NSCacheElement * iter = conTopicList->head;
    conTopicList->cacheType = NS_PROVIDER_CACHE_CONSUMER_TOPIC_CID;

    while (iter)
    {
        NSCacheTopicSubData * curr = (NSCacheTopicSubData *)iter->data;

        if (curr && strcmp(curr->id, consumerId) == 0)
        {
            NS_LOG_V(INFO_PRIVATE, "curr->id = %s", curr->id);
            NS_LOG_V(DEBUG, "curr->topicName = %s", curr->topicName);
            NSTopicLL * topicIter = topics;

            while (topicIter)
            {
                if (strcmp(topicIter->topicName, curr->topicName) == 0)
                {
                    topicIter->state = NS_TOPIC_SUBSCRIBED;
                    break;
                }

                topicIter = topicIter->next;
            }
        }

        iter = iter->next;
    }

    conTopicList->cacheType = NS_PROVIDER_CACHE_CONSUMER_TOPIC_NAME;
    pthread_mutex_unlock(&NSCacheMutex);
    NS_LOG(DEBUG, "NSProviderGetConsumerTopics - OUT");

    return topics;
}
示例#19
0
NSCacheElement * NSConsumerStorageRead(NSCacheList * list, const char * findId)
{
    NS_VERIFY_NOT_NULL(list, NULL);
    NS_VERIFY_NOT_NULL(findId, NULL);

    pthread_mutex_t * mutex = NSGetCacheMutex();
    pthread_mutex_lock(mutex);

    NSCacheElement * iter = list->head;
    NSCacheType type = list->cacheType;

    while (iter)
    {
        if (NSConsumerCompareIdCacheData(type, iter->data, findId))
        {
            pthread_mutex_unlock(mutex);
            return iter;
        }

        iter = iter->next;
    }

    NS_LOG (DEBUG, "No Cache Element");
    pthread_mutex_unlock(mutex);
    return NULL;
}
示例#20
0
NSResult NSPublishResourceToCloud(char *serverAddress)
{

    NS_LOG(DEBUG, "NSPublishResourceToCloud - IN");
    NS_LOG_V(DEBUG, "Cloud address: %s", serverAddress);

    const char * publishQuery = "/oic/rd?rt=oic.wk.rdpub";

    if (NSCloudPublish(serverAddress, publishQuery, &NSHandlePublishCb, 1,
            NotificationResource.handle) != OC_STACK_OK)
    {
        NS_LOG(DEBUG, "Unable to publish resources to cloud");
    }

    NS_LOG(DEBUG, "NSPublishResourceToCloud - OUT");
    return NS_OK;
}
示例#21
0
bool NSInitScheduler()
{
    NS_LOG(DEBUG, "NSInitScheduler - IN");

    int i = 0;

    for (i = 0; i < THREAD_COUNT; i++)
    {
        pthread_mutex_init(&NSMutex[i], NULL);
        NSIsRunning[i] = true;
        sem_init(&(NSSemaphore[i]), 0, 0);
    }

    NS_LOG(DEBUG, "NSInitScheduler - OUT");

    return true;
}
示例#22
0
NSResult NSProviderStorageDelete(NSCacheList * list, const char * delId)
{
    pthread_mutex_lock(&NSCacheMutex);
    NSCacheElement * prev = list->head;
    NSCacheElement * del = list->head;

    NSCacheType type = list->cacheType;

    if (!del)
    {
        NS_LOG(DEBUG, "list head is NULL");
        pthread_mutex_unlock(&NSCacheMutex);
        return NS_FAIL;
    }

    if (NSProviderCompareIdCacheData(type, del->data, delId))
    {
        if (del == list->head) // first object
        {
            if (del == list->tail) // first object (one object)
            {
                list->tail = del->next;
            }

            list->head = del->next;
            NSProviderDeleteCacheData(type, del->data);
            NSOICFree(del);
            pthread_mutex_unlock(&NSCacheMutex);
            return NS_OK;
        }
    }

    del = del->next;

    while (del)
    {
        if (NSProviderCompareIdCacheData(type, del->data, delId))
        {
            if (del == list->tail) // delete object same to last object
            {
                list->tail = prev;
            }

            prev->next = del->next;
            NSProviderDeleteCacheData(type, del->data);
            NSOICFree(del);
            pthread_mutex_unlock(&NSCacheMutex);
            return NS_OK;
        }

        prev = del;
        del = del->next;
    }

    pthread_mutex_unlock(&NSCacheMutex);
    return NS_FAIL;
}
void NSConsumerInternalTaskProcessing(NSTask * task)
{
    NS_VERIFY_NOT_NULL_V(task);

    NS_LOG_V(DEBUG, "Receive Event : %d", (int)task->taskType);
    switch (task->taskType)
    {
        case TASK_CONSUMER_RECV_SUBSCRIBE_CONFIRMED:
        {
            NS_LOG(DEBUG, "Receive Subscribe confirm from provider.");
            NSConsumerHandleRecvSubscriptionConfirmed((NSMessage *)task->taskData);
            NSRemoveMessage((NSMessage *)task->taskData);
            break;
        }
        case TASK_CONSUMER_RECV_MESSAGE:
        {
            NS_LOG(DEBUG, "Receive New Notification");
            NSConsumerHandleRecvMessage((NSMessage *)task->taskData);
            NSRemoveMessage((NSMessage *)task->taskData);
            break;
        }
        case TASK_CONSUMER_PROVIDER_DISCOVERED:
        {
            NS_LOG(DEBUG, "Receive New Provider is discovered.");
            NSConsumerHandleProviderDiscovered((NSProvider_internal *)task->taskData);
            NSRemoveProvider((NSProvider_internal *)task->taskData);
            break;
        }
        case TASK_RECV_SYNCINFO:
        {
            NS_LOG(DEBUG, "Receive SyncInfo.");
            NSConsumerHandleRecvSyncInfo((NSSyncInfo *)task->taskData);
            NSOICFree(task->taskData);
            break;
        }
        case TASK_MAKE_SYNCINFO:
        {
            NS_LOG(DEBUG, "Make SyncInfo, get Provider's Addr");
            NSConsumerHandleMakeSyncInfo((NSSyncInfo *)task->taskData);
            NSOICFree(task->taskData);
            break;
        }
        case TASK_CONSUMER_REQ_SUBSCRIBE_CANCEL:
        {
            NS_LOG(DEBUG, "Make Subscribe cancel from provider.");
            NSConsumerHandleProviderDeleted((NSProvider_internal *)task->taskData);
            NSRemoveProvider((NSProvider_internal *)task->taskData);
            break;
        }
        default :
        {
            NS_LOG(ERROR, "Unknown TASK Type");
            return ;
        }
    }
    NSOICFree(task);
}
示例#24
0
NSResult NSSetSyncPayload(NSSyncInfo *sync, OCRepPayload** syncPayload)
{
    NS_LOG(DEBUG, "NSSetSyncPayload - IN");

    *syncPayload = OCRepPayloadCreate();

    if (!*syncPayload)
    {
        NS_LOG(ERROR, "Failed to allocate payload");
        return NS_ERROR;
    }

    OCRepPayloadSetUri(*syncPayload, NS_COLLECTION_SYNC_URI);

    OCRepPayloadSetPropString(*syncPayload, NS_ATTRIBUTE_PROVIDER_ID, sync->providerId);
    OCRepPayloadSetPropInt(*syncPayload, NS_ATTRIBUTE_MESSAGE_ID, sync->messageId);
    OCRepPayloadSetPropInt(*syncPayload, NS_ATTRIBUTE_STATE, sync->state);

    NS_LOG(DEBUG, "NSSetSyncPayload - OUT");
    return NS_OK;
}
示例#25
0
OCStackResult NSProviderPublishTopic(OCRepPayload * payload, OCClientResponseHandler response)
{
    NS_LOG(DEBUG, "NSProviderPublishTopic - IN");
    OCCallbackData cbData;
    memset(&cbData, 0, sizeof(OCCallbackData));
    cbData.cb = response;
    cbData.cd = NULL;
    cbData.context = NULL;

    NSMQServerInfo * serverInfo = NSGetMQServerInfo();

    if (!serverInfo)
    {
        NS_LOG(DEBUG, "serverInfo is not NULL");
        NS_LOG_V(DEBUG, "serverInfo->serverUri = %s", serverInfo->serverUri);
    }

    NS_LOG(DEBUG, "NSProviderPublishTopic - OUT");

    return OCDoResource(NULL, OC_REST_POST, serverInfo->serverUri, serverInfo->devAddr,
            (OCPayload *)payload, CT_ADAPTER_TCP, OC_LOW_QOS, &cbData, NULL, 0);
}
void NSConsumerHandleRecvSubscriptionConfirmed(NSMessage * msg)
{
    NS_VERIFY_NOT_NULL_V(msg);

    NS_LOG_V(DEBUG, "confirmed by : %s", msg->providerId);
    NSProvider_internal * provider = NSProviderCacheFind(msg->providerId);
    NS_VERIFY_NOT_NULL_V(provider);

    if (provider->connection->next == NULL)
    {
        NS_LOG(DEBUG, "call back to user");
        NSSubscriptionAccepted((NSProvider *) provider);
    }
}
示例#27
0
OCStackApplicationResult NSHandlePublishCb(void *ctx, OCDoHandle handle,
    OCClientResponse *clientResponse)
{
    (void) handle;

    if (ctx != (void *)DEFAULT_CONTEXT_VALUE)
    {
        NS_LOG(DEBUG, "Invalid publish callback received");
    }

    NS_LOG_V(DEBUG, "Publish resource response received code: %d", clientResponse->result);

    return OC_STACK_KEEP_TRANSACTION;
}
void NSCancelAllSubscription()
{
    NSCacheList * ProviderCache = *(NSGetProviderCacheList());
    if (!ProviderCache)
    {
        NS_LOG(DEBUG, "Provider Cache Init");
        ProviderCache = NSStorageCreate();
        NS_VERIFY_NOT_NULL_V(ProviderCache);

        ProviderCache->cacheType = NS_CONSUMER_CACHE_PROVIDER;
        NSSetProviderCacheList(ProviderCache);
    }

    NSCacheElement * obj = NULL;
    while ((obj = NSPopProviderCacheList(ProviderCache)))
    {
        NS_LOG(DEBUG, "build NSTask");
        NSTask * task = NSMakeTask(TASK_CONSUMER_REQ_SUBSCRIBE_CANCEL, (void *) obj->data);
        NS_VERIFY_NOT_NULL_V(task);

        NSConsumerPushEvent(task);
    }
}
NSResult NSMessageCacheUpdate(NSMessage * msg, NSSyncType type)
{
    NS_VERIFY_NOT_NULL(msg, NS_ERROR);

    NSCacheList * MessageCache = *(NSGetMessageCacheList());
    if (!MessageCache)
    {
        NS_LOG(DEBUG, "Message Cache Init");
        MessageCache = NSStorageCreate();
        NS_VERIFY_NOT_NULL(MessageCache, NS_ERROR);

        MessageCache->cacheType = NS_CONSUMER_CACHE_MESSAGE;
        NSSetMessageCacheList(MessageCache);
    }

    NSStoreMessage * sMsg = (NSStoreMessage *)OICMalloc(sizeof(NSStoreMessage));
    NS_VERIFY_NOT_NULL(sMsg, NS_ERROR);

    NSCacheElement * obj = (NSCacheElement *)OICMalloc(sizeof(NSCacheElement));
    NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(obj, NS_ERROR, NSOICFree(sMsg));

    sMsg->status = type;
    sMsg->msg = NSCopyMessage(msg);

    obj->data = (NSCacheData *) sMsg;
    obj->next = NULL;

    NS_LOG(DEBUG, "try to write to storage");
    NSResult ret = NSStorageWrite(MessageCache, obj);
    NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(ret == NS_OK ? (void *) 1 : NULL,
            NS_ERROR, NSRemoveCacheElementMessage(obj));

    NSRemoveCacheElementMessage(obj);

    NS_LOG(DEBUG, "Update message done");
    return NS_OK;
}
示例#30
0
void NSPushQueue(NSSchedulerType schedulerType, NSTaskType taskType, void* data)
{

    if(!NSIsRunning[schedulerType])
    {
        return;
    }

    pthread_mutex_lock(&NSMutex[schedulerType]);

    NS_LOG(DEBUG, "NSPushQueue - IN");
    NS_LOG_V(DEBUG, "NSSchedulerType = %d", schedulerType);
    NS_LOG_V(DEBUG, "NSTaskType = %d", taskType);

    if (NSHeadMsg[schedulerType] == NULL)
    {
        NSHeadMsg[schedulerType] = (NSTask*) OICMalloc(sizeof(NSTask));
        NSHeadMsg[schedulerType]->taskType = taskType;
        NSHeadMsg[schedulerType]->taskData = data;
        NSHeadMsg[schedulerType]->nextTask = NULL;
        NSTailMsg[schedulerType] = NSHeadMsg[schedulerType];
    }
    else
    {
        NSTask* newNode = (NSTask*) OICMalloc(sizeof(NSTask));
        newNode->taskType = taskType;
        newNode->taskData = data;
        newNode->nextTask = NULL;

        NSTailMsg[schedulerType]->nextTask = newNode;
        NSTailMsg[schedulerType] = newNode;
    }

    sem_post(&(NSSemaphore[schedulerType]));
    NS_LOG(DEBUG, "NSPushQueue - OUT");
    pthread_mutex_unlock(&NSMutex[schedulerType]);
}