service/things-manager/sampleapp/linux/configuration/con-server.cpp

   1 //******************************************************************
   2 //
   3 // Copyright 2014 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 ///
  22 /// This sample shows how one could create a resource (collection) with children.
  23 ///
  24
  25 #include <functional>
  26 #include <thread>
  27
  28 #include "OCPlatform.h"
  29 #include "OCApi.h"
  30 #include "ThingsManager.h"
  31 #include "ConfigurationCollection.h"
  32 #include "DiagnosticsCollection.h"
  33 #include "FactorySetCollection.h"
  34
  35 using namespace OC;
  36 using namespace OIC;
  37
  38 const int SUCCESS_RESPONSE = 0;
  39 int g_Steps = 0;
  40 int isWaiting = 0;
  41
  42 // Default system configuration value's variables
  43 // The variable's names should be same as the names of "extern" variables defined in
  44 // "ConfigurationResource.h"
  45 std::string defaultLocation;
  46 std::string defaultRegion;
  47 std::string defaultSystemTime;
  48 std::string defaultCurrency;
  49
  50 static ThingsManager* g_thingsmanager;
  51
  52 // Forward declaring the entityHandler (Configuration)
  53 bool prepareResponseForResource(std::shared_ptr< OCResourceRequest > request);
  54 OCStackResult sendResponseForResource(std::shared_ptr< OCResourceRequest > pRequest);
  55 OCEntityHandlerResult entityHandlerForResource(std::shared_ptr< OCResourceRequest > request);
  56
  57 ConfigurationResource *myConfigurationResource;
  58 DiagnosticsResource *myDiagnosticsResource;
  59 FactorySetResource *myFactorySetResource;
  60
  61 typedef std::function< void(OCRepresentation&) > putFunc;
  62 typedef std::function< OCRepresentation(void) > getFunc;
  63
  64 getFunc getGetFunction(std::string uri)
  65 {
  66     getFunc res = NULL;
  67
  68     if (uri == myConfigurationResource->getUri())
  69     {
  70         res = std::bind(&ConfigurationResource::getConfigurationRepresentation,
  71                 myConfigurationResource);
  72     }
  73     else if (uri == myDiagnosticsResource->getUri())
  74     {
  75         res = std::bind(&DiagnosticsResource::getDiagnosticsRepresentation,
  76                 myDiagnosticsResource);
  77     }
  78
  79     return res;
  80 }
  81
  82 putFunc getPutFunction(std::string uri)
  83 {
  84     putFunc res = NULL;
  85
  86     if (uri == myConfigurationResource->getUri())
  87     {
  88         res = std::bind(&ConfigurationResource::setConfigurationRepresentation,
  89                 myConfigurationResource, std::placeholders::_1);
  90     }
  91     else if (uri == myDiagnosticsResource->getUri())
  92     {
  93         res = std::bind(&DiagnosticsResource::setDiagnosticsRepresentation,
  94                 myDiagnosticsResource, std::placeholders::_1);
  95     }
  96
  97     return res;
  98 }
  99
 100 // This function prepares a response for any incoming request to Light resource.
 101 bool prepareResponseForResource(std::shared_ptr< OCResourceRequest > request)
 102 {
 103     std::cout << "\tIn Server CPP prepareResponseForResource:\n";
 104     bool result = false;
 105     if (request)
 106     {
 107         // Get the request type and request flag
 108         std::string requestType = request->getRequestType();
 109         int requestFlag = request->getRequestHandlerFlag();
 110
 111         if (requestFlag == RequestHandlerFlag::RequestFlag)
 112         {
 113             std::cout << "\t\trequestFlag : Request\n";
 114
 115             // If the request type is GET
 116             if (requestType == "GET")
 117             {
 118                 std::cout << "\t\t\trequestType : GET\n";
 119                 // GET operations are directly handled while sending the response
 120                 // in the sendLightResponse function
 121                 result = true;
 122             }
 123             else if (requestType == "PUT")
 124             {
 125                 std::cout << "\t\t\trequestType : PUT\n";
 126                 putFunc putFunction;
 127                 OCRepresentation rep = request->getResourceRepresentation();
 128
 129                 putFunction = getPutFunction(request->getResourceUri());
 130
 131                 // Do related operations related to PUT request
 132                 putFunction(rep);
 133                 result = true;
 134             }
 135             else if (requestType == "POST")
 136             {
 137                 // POST request operations
 138             }
 139             else if (requestType == "DELETE")
 140             {
 141                 // DELETE request operations
 142             }
 143         }
 144         else if (requestFlag == RequestHandlerFlag::ObserverFlag)
 145         {
 146             std::cout << "\t\trequestFlag : Observer\n";
 147         }
 148     }
 149     else
 150     {
 151         std::cout << "Request invalid" << std::endl;
 152     }
 153
 154     return result;
 155 }
 156
 157 OCStackResult sendResponseForResource(std::shared_ptr< OCResourceRequest > pRequest)
 158 {
 159     auto pResponse = std::make_shared< OC::OCResourceResponse >();
 160
 161     // Check for query params (if any)
 162     QueryParamsMap queryParamsMap = pRequest->getQueryParameters();
 163
 164     pResponse->setRequestHandle(pRequest->getRequestHandle());
 165     pResponse->setResourceHandle(pRequest->getResourceHandle());
 166
 167     getFunc getFunction;
 168     getFunction = getGetFunction(pRequest->getResourceUri());
 169
 170     OCRepresentation rep;
 171     rep = getFunction();
 172
 173     auto findRes = queryParamsMap.find("if");
 174
 175     if (findRes != queryParamsMap.end())
 176     {
 177         pResponse->setResourceRepresentation(rep, findRes->second);
 178     }
 179     else
 180     {
 181         pResponse->setResourceRepresentation(rep, DEFAULT_INTERFACE);
 182     }
 183
 184     pResponse->setErrorCode(200);
 185     pResponse->setResponseResult(OC_EH_OK);
 186
 187     return OCPlatform::sendResponse(pResponse);
 188 }
 189
 190 OCEntityHandlerResult entityHandlerForResource(std::shared_ptr< OCResourceRequest > request)
 191 {
 192     std::cout << "\tIn Server CPP (entityHandlerForResource) entity handler:\n";
 193     OCEntityHandlerResult ehResult = OC_EH_ERROR;
 194
 195     QueryParamsMap test = request->getQueryParameters();
 196
 197     if (prepareResponseForResource(request))
 198     {
 199         if (OC_STACK_OK == sendResponseForResource(request))
 200         {
 201             ehResult = OC_EH_OK;
 202         }
 203         else
 204         {
 205             std::cout << "sendResponse failed." << std::endl;
 206         }
 207     }
 208     else
 209     {
 210         std::cout << "PrepareResponse failed." << std::endl;
 211     }
 212     return ehResult;
 213 }
 214
 215 // callback handler on GET request
 216 void onBootstrap(const HeaderOptions& headerOptions, const OCRepresentation& rep, const int eCode)
 217 {
 218     isWaiting = 0;
 219
 220     if (eCode != SUCCESS_RESPONSE)
 221     {
 222         std::cout << "onGET Response error: " << eCode << std::endl;
 223         return ;
 224     }
 225
 226     std::cout << "\n\nGET request was successful" << std::endl;
 227     std::cout << "\tResource URI: " << rep.getUri() << std::endl;
 228
 229     defaultRegion = rep.getValue< std::string >("r");
 230     defaultSystemTime = rep.getValue< std::string >("st");
 231     defaultCurrency = rep.getValue< std::string >("c");
 232     defaultLocation = rep.getValue< std::string >("loc");
 233
 234     std::cout << "\tLocation : " << defaultLocation << std::endl;
 235     std::cout << "\tSystemTime : " << defaultSystemTime << std::endl;
 236     std::cout << "\tCurrency : " << defaultCurrency << std::endl;
 237     std::cout << "\tRegion : " << defaultRegion << std::endl;
 238
 239 }
 240
 241 int main()
 242 {
 243     //**************************************************************
 244     // STEP 0
 245     // Create PlatformConfig object
 246     PlatformConfig cfg
 247     { OC::ServiceType::InProc, OC::ModeType::Both, "0.0.0.0", 0, OC::QualityOfService::LowQos };
 248
 249     OCPlatform::Configure(cfg);
 250     g_thingsmanager = new ThingsManager();
 251     //**************************************************************
 252
 253     if (getuid() != 0)
 254     {
 255         std::cout << "NOTE: You may gain the root privilege (e.g, reboot)\n";
 256         std::cout << "NOTE: Now, you don't have it.\n";
 257     }
 258
 259     try
 260     {
 261         // Perform app tasks
 262         while (true)
 263         {
 264
 265             if (isWaiting > 0)
 266                 continue;
 267
 268             isWaiting = 0;
 269
 270             std::cout << endl << endl << "(0) Quit" << std::endl;
 271             std::cout << "(1) Bootstrap" << std::endl;
 272             std::cout << "(2) Create Configuration Resources" << std::endl;
 273
 274             cin >> g_Steps;
 275             //
 276             if (g_Steps == 0)
 277                 break;
 278             else if (g_Steps == 1)
 279             {
 280                 if( g_thingsmanager->doBootstrap(&onBootstrap) == OC_STACK_OK)
 281                     isWaiting = 1;
 282                 else
 283                     std::cout << "A callback pointer of the function is NULL." << std::endl;
 284             }
 285             else if (g_Steps == 2)
 286             {
 287                 myConfigurationResource = new ConfigurationResource();
 288                 myConfigurationResource->createResources(&entityHandlerForResource);
 289
 290                 myDiagnosticsResource = new DiagnosticsResource();
 291                 myDiagnosticsResource->createResources(&entityHandlerForResource);
 292
 293
 294                 myFactorySetResource = new FactorySetResource();
 295                 myFactorySetResource->createResources(&entityHandlerForResource);
 296                 myDiagnosticsResource->factoryReset = std::function < void()
 297                         > (std::bind(&ConfigurationResource::factoryReset,
 298                                 myConfigurationResource));
 299
 300                 isWaiting = 1;
 301             }
 302         }
 303     }
 304     catch (OCException e)
 305     {
 306         std::cout << "Exception in main: " << e.what();
 307     }
 308
 309     // No explicit call to stop the platform.
 310     // When OCPlatform destructor is invoked, internally we do platform cleanup
 311     return 0;
 312 }
 313