Merge "Fixed klocwork issues in C++ Stack"
[platform/upstream/iotivity.git] / resource / examples / simpleserver.cpp
1 //******************************************************************
2 //
3 // Copyright 2014 Intel Mobile Communications GmbH 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 ///
22 /// This sample provides steps to define an interface for a resource
23 /// (properties and methods) and host this resource on the server.
24 ///
25
26 #include <functional>
27
28 #include <pthread.h>
29 #include <mutex>
30 #include <condition_variable>
31
32 #include "OCPlatform.h"
33 #include "OCApi.h"
34
35 using namespace OC;
36 using namespace std;
37 namespace PH = std::placeholders;
38
39 int gObservation = 0;
40 void * ChangeLightRepresentation (void *param);
41 void * handleSlowResponse (void *param, std::shared_ptr<OCResourceRequest> pRequest);
42
43 // Specifies where to notify all observers or list of observers
44 // false: notifies all observers
45 // true: notifies list of observers
46 bool isListOfObservers = false;
47
48 // Specifies secure or non-secure
49 // false: non-secure resource
50 // true: secure resource
51 bool isSecure = false;
52
53 /// Specifies whether Entity handler is going to do slow response or not
54 bool isSlowResponse = false;
55
56 // Forward declaring the entityHandler
57
58 /// This class represents a single resource named 'lightResource'. This resource has
59 /// two simple properties named 'state' and 'power'
60
61 class LightResource
62 {
63
64 public:
65     /// Access this property from a TB client
66     std::string m_name;
67     bool m_state;
68     int m_power;
69     std::string m_lightUri;
70     OCResourceHandle m_resourceHandle;
71     OCRepresentation m_lightRep;
72     ObservationIds m_interestedObservers;
73
74 public:
75     /// Constructor
76     LightResource()
77         :m_name("John's light"), m_state(false), m_power(0), m_lightUri("/a/light") {
78         // Initialize representation
79         m_lightRep.setUri(m_lightUri);
80
81         m_lightRep.setValue("state", m_state);
82         m_lightRep.setValue("power", m_power);
83         m_lightRep.setValue("name", m_name);
84     }
85
86     /* Note that this does not need to be a member function: for classes you do not have
87     access to, you can accomplish this with a free function: */
88
89     /// This function internally calls registerResource API.
90     void createResource()
91     {
92         std::string resourceURI = m_lightUri; //URI of the resource
93         std::string resourceTypeName = "core.light"; //resource type name. In this case, it is light
94         std::string resourceInterface = DEFAULT_INTERFACE; // resource interface.
95
96         // OCResourceProperty is defined ocstack.h
97         uint8_t resourceProperty;
98         if(isSecure)
99         {
100             resourceProperty = OC_DISCOVERABLE | OC_OBSERVABLE | OC_SECURE;
101         }
102         else
103         {
104             resourceProperty = OC_DISCOVERABLE | OC_OBSERVABLE;
105         }
106         EntityHandler cb = std::bind(&LightResource::entityHandler, this,PH::_1);
107
108         // This will internally create and register the resource.
109         OCStackResult result = OCPlatform::registerResource(
110                                     m_resourceHandle, resourceURI, resourceTypeName,
111                                     resourceInterface, cb, resourceProperty);
112
113         if (OC_STACK_OK != result)
114         {
115             cout << "Resource creation was unsuccessful\n";
116         }
117     }
118
119     OCStackResult createResource1()
120     {
121         std::string resourceURI = "/a/light1"; // URI of the resource
122         std::string resourceTypeName = "core.light"; // resource type name. In this case, it is light
123         std::string resourceInterface = DEFAULT_INTERFACE; // resource interface.
124
125         // OCResourceProperty is defined ocstack.h
126         uint8_t resourceProperty;
127         if(isSecure)
128         {
129             resourceProperty = OC_DISCOVERABLE | OC_OBSERVABLE | OC_SECURE;
130         }
131         else
132         {
133             resourceProperty = OC_DISCOVERABLE | OC_OBSERVABLE;
134         }
135         EntityHandler cb = std::bind(&LightResource::entityHandler, this,PH::_1);
136
137         OCResourceHandle resHandle;
138
139         // This will internally create and register the resource.
140         OCStackResult result = OCPlatform::registerResource(
141                                     resHandle, resourceURI, resourceTypeName,
142                                     resourceInterface, cb, resourceProperty);
143
144         if (OC_STACK_OK != result)
145         {
146             cout << "Resource creation was unsuccessful\n";
147         }
148
149         return result;
150     }
151
152     OCResourceHandle getHandle()
153     {
154         return m_resourceHandle;
155     }
156
157     // Puts representation.
158     // Gets values from the representation and
159     // updates the internal state
160     void put(OCRepresentation& rep)
161     {
162         try {
163             if (rep.getValue("state", m_state))
164             {
165                 cout << "\t\t\t\t" << "state: " << m_state << endl;
166             }
167             else
168             {
169                 cout << "\t\t\t\t" << "state not found in the representation" << endl;
170             }
171
172             if (rep.getValue("power", m_power))
173             {
174                 cout << "\t\t\t\t" << "power: " << m_power << endl;
175             }
176             else
177             {
178                 cout << "\t\t\t\t" << "power not found in the representation" << endl;
179             }
180         }
181         catch (exception& e)
182         {
183             cout << e.what() << endl;
184         }
185
186     }
187
188     // Post representation.
189     // Post can create new resource or simply act like put.
190     // Gets values from the representation and
191     // updates the internal state
192     OCRepresentation post(OCRepresentation& rep)
193     {
194         static int first = 1;
195
196         // for the first time it tries to create a resource
197         if(first)
198         {
199             first = 0;
200
201             if(OC_STACK_OK == createResource1())
202             {
203                 OCRepresentation rep1;
204                 rep1.setValue("createduri", std::string("/a/light1"));
205
206                 return rep1;
207             }
208         }
209
210         // from second time onwards it just puts
211         put(rep);
212         return get();
213     }
214
215
216     // gets the updated representation.
217     // Updates the representation with latest internal state before
218     // sending out.
219     OCRepresentation get()
220     {
221         m_lightRep.setValue("state", m_state);
222         m_lightRep.setValue("power", m_power);
223
224         return m_lightRep;
225     }
226
227     void addType(const std::string& type) const
228     {
229         OCStackResult result = OCPlatform::bindTypeToResource(m_resourceHandle, type);
230         if (OC_STACK_OK != result)
231         {
232             cout << "Binding TypeName to Resource was unsuccessful\n";
233         }
234     }
235
236     void addInterface(const std::string& interface) const
237     {
238         OCStackResult result = OCPlatform::bindInterfaceToResource(m_resourceHandle, interface);
239         if (OC_STACK_OK != result)
240         {
241             cout << "Binding TypeName to Resource was unsuccessful\n";
242         }
243     }
244
245 private:
246 // This is just a sample implementation of entity handler.
247 // Entity handler can be implemented in several ways by the manufacturer
248 OCEntityHandlerResult entityHandler(std::shared_ptr<OCResourceRequest> request)
249 {
250     cout << "\tIn Server CPP entity handler:\n";
251     OCEntityHandlerResult ehResult = OC_EH_ERROR;
252     if(request)
253     {
254         // Get the request type and request flag
255         std::string requestType = request->getRequestType();
256         int requestFlag = request->getRequestHandlerFlag();
257
258         if(requestFlag & RequestHandlerFlag::InitFlag)
259         {
260             cout << "\t\trequestFlag : Init\n";
261
262             // entity handler to perform resource initialization operations
263         }
264         if(requestFlag & RequestHandlerFlag::RequestFlag)
265         {
266             cout << "\t\trequestFlag : Request\n";
267             auto pResponse = std::make_shared<OC::OCResourceResponse>();
268             pResponse->setRequestHandle(request->getRequestHandle());
269             pResponse->setResourceHandle(request->getResourceHandle());
270
271             // If the request type is GET
272             if(requestType == "GET")
273             {
274                 cout << "\t\t\trequestType : GET\n";
275                 if(isSlowResponse) // Slow response case
276                 {
277                     static int startedThread = 0;
278                     if(!startedThread)
279                     {
280                         std::thread t(handleSlowResponse, (void *)this, request);
281                         startedThread = 1;
282                         t.detach();
283                     }
284                     ehResult = OC_EH_SLOW;
285                 }
286                 else // normal response case.
287                 {
288                     pResponse->setErrorCode(200);
289                     pResponse->setResponseResult(OC_EH_OK);
290                     pResponse->setResourceRepresentation(get());
291                     if(OC_STACK_OK == OCPlatform::sendResponse(pResponse))
292                     {
293                         ehResult = OC_EH_OK;
294                     }
295                 }
296             }
297             else if(requestType == "PUT")
298             {
299                 cout << "\t\t\trequestType : PUT\n";
300                 OCRepresentation rep = request->getResourceRepresentation();
301
302                 // Do related operations related to PUT request
303                 // Update the lightResource
304                 put(rep);
305                 pResponse->setErrorCode(200);
306                 pResponse->setResponseResult(OC_EH_OK);
307                 pResponse->setResourceRepresentation(get());
308                 if(OC_STACK_OK == OCPlatform::sendResponse(pResponse))
309                 {
310                     ehResult = OC_EH_OK;
311                 }
312             }
313             else if(requestType == "POST")
314             {
315                 cout << "\t\t\trequestType : POST\n";
316
317                 OCRepresentation rep = request->getResourceRepresentation();
318
319                 // Do related operations related to POST request
320                 OCRepresentation rep_post = post(rep);
321                 pResponse->setResourceRepresentation(rep_post);
322                 pResponse->setErrorCode(200);
323                 if(rep_post.hasAttribute("createduri"))
324                 {
325                     pResponse->setResponseResult(OC_EH_RESOURCE_CREATED);
326                     pResponse->setNewResourceUri(rep_post.getValue<std::string>("createduri"));
327                 }
328
329                 if(OC_STACK_OK == OCPlatform::sendResponse(pResponse))
330                 {
331                     ehResult = OC_EH_OK;
332                 }
333             }
334             else if(requestType == "DELETE")
335             {
336                 // DELETE request operations
337             }
338         }
339
340         if(requestFlag & RequestHandlerFlag::ObserverFlag)
341         {
342             ObservationInfo observationInfo = request->getObservationInfo();
343             if(ObserveAction::ObserveRegister == observationInfo.action)
344             {
345                 m_interestedObservers.push_back(observationInfo.obsId);
346             }
347             else if(ObserveAction::ObserveUnregister == observationInfo.action)
348             {
349                 m_interestedObservers.erase(std::remove(
350                                                             m_interestedObservers.begin(),
351                                                             m_interestedObservers.end(),
352                                                             observationInfo.obsId),
353                                                             m_interestedObservers.end());
354             }
355
356             pthread_t threadId;
357
358             cout << "\t\trequestFlag : Observer\n";
359             gObservation = 1;
360             static int startedThread = 0;
361
362             // Observation happens on a different thread in ChangeLightRepresentation function.
363             // If we have not created the thread already, we will create one here.
364             if(!startedThread)
365             {
366                 pthread_create (&threadId, NULL, ChangeLightRepresentation, (void *)this);
367                 startedThread = 1;
368             }
369             ehResult = OC_EH_OK;
370         }
371     }
372     else
373     {
374         std::cout << "Request invalid" << std::endl;
375     }
376
377     return ehResult;
378 }
379
380 };
381
382 // ChangeLightRepresentaion is an observation function,
383 // which notifies any changes to the resource to stack
384 // via notifyObservers
385 void * ChangeLightRepresentation (void *param)
386 {
387     LightResource* lightPtr = (LightResource*) param;
388
389     // This function continuously monitors for the changes
390     while (1)
391     {
392         sleep (5);
393
394         if (gObservation)
395         {
396             // If under observation if there are any changes to the light resource
397             // we call notifyObservors
398             //
399             // For demostration we are changing the power value and notifying.
400             lightPtr->m_power += 10;
401
402             cout << "\nPower updated to : " << lightPtr->m_power << endl;
403             cout << "Notifying observers with resource handle: " << lightPtr->getHandle() << endl;
404
405             OCStackResult result = OC_STACK_OK;
406
407             if(isListOfObservers)
408             {
409                 std::shared_ptr<OCResourceResponse> resourceResponse(new OCResourceResponse());
410
411                 resourceResponse->setErrorCode(200);
412                 resourceResponse->setResourceRepresentation(lightPtr->get(), DEFAULT_INTERFACE);
413
414                 result = OCPlatform::notifyListOfObservers(  lightPtr->getHandle(),
415                                                              lightPtr->m_interestedObservers,
416                                                              resourceResponse);
417             }
418             else
419             {
420                 result = OCPlatform::notifyAllObservers(lightPtr->getHandle());
421             }
422
423             if(OC_STACK_NO_OBSERVERS == result)
424             {
425                 cout << "No More observers, stopping notifications" << endl;
426                 gObservation = 0;
427             }
428         }
429     }
430
431     return NULL;
432 }
433
434 void * handleSlowResponse (void *param, std::shared_ptr<OCResourceRequest> pRequest)
435 {
436     // This function handles slow response case
437     LightResource* lightPtr = (LightResource*) param;
438     // Induce a case for slow response by using sleep
439     std::cout << "SLOW response" << std::endl;
440     sleep (10);
441
442     auto pResponse = std::make_shared<OC::OCResourceResponse>();
443     pResponse->setRequestHandle(pRequest->getRequestHandle());
444     pResponse->setResourceHandle(pRequest->getResourceHandle());
445     pResponse->setResourceRepresentation(lightPtr->get());
446     pResponse->setErrorCode(200);
447     pResponse->setResponseResult(OC_EH_OK);
448
449     // Set the slow response flag back to false
450     isSlowResponse = false;
451     OCPlatform::sendResponse(pResponse);
452     return NULL;
453 }
454
455 void PrintUsage()
456 {
457     std::cout << std::endl;
458     std::cout << "Usage : simpleserver <value>\n";
459     std::cout << "    Default - Non-secure resource and notify all observers\n";
460     std::cout << "    1 - Non-secure resource and notify list of observers\n\n";
461     std::cout << "    2 - Secure resource and notify all observers\n";
462     std::cout << "    3 - Secure resource and notify list of observers\n\n";
463     std::cout << "    4 - Non-secure resource, GET slow response, notify all observers\n";
464 }
465
466
467 int main(int argc, char* argv[])
468 {
469     PrintUsage();
470
471     if (argc == 1)
472     {
473         isListOfObservers = false;
474         isSecure = false;
475     }
476     else if (argc == 2)
477     {
478         int value = atoi(argv[1]);
479         switch (value)
480         {
481             case 1:
482                 isListOfObservers = true;
483                 isSecure = false;
484                 break;
485             case 2:
486                 isListOfObservers = false;
487                 isSecure = true;
488                 break;
489             case 3:
490                 isListOfObservers = true;
491                 isSecure = true;
492                 break;
493             case 4:
494                 isSlowResponse = true;
495             default:
496                 break;
497        }
498      }
499     else
500     {
501         return -1;
502     }
503
504     // Create PlatformConfig object
505     PlatformConfig cfg {
506         OC::ServiceType::InProc,
507         OC::ModeType::Server,
508         "0.0.0.0", // By setting to "0.0.0.0", it binds to all available interfaces
509         0,         // Uses randomly available port
510         OC::QualityOfService::LowQos
511     };
512
513     OCPlatform::Configure(cfg);
514     try
515     {
516         // Create the instance of the resource class
517         // (in this case instance of class 'LightResource').
518         LightResource myLight;
519
520         // Invoke createResource function of class light.
521         myLight.createResource();
522
523         myLight.addType(std::string("core.brightlight"));
524         myLight.addInterface(std::string("oc.mi.ll"));
525
526         // A condition variable will free the mutex it is given, then do a non-
527         // intensive block until 'notify' is called on it.  In this case, since we
528         // don't ever call cv.notify, this should be a non-processor intensive version
529         // of while(true);
530         std::mutex blocker;
531         std::condition_variable cv;
532         std::unique_lock<std::mutex> lock(blocker);
533         cv.wait(lock);
534     }
535     catch(OCException e)
536     {
537         //log(e.what());
538     }
539
540     // No explicit call to stop the platform.
541     // When OCPlatform::destructor is invoked, internally we do platform cleanup
542
543     return 0;
544 }