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::InitFlag)
 112         {
 113             std::cout << "\t\trequestFlag : Init\n";
 114
 115             // entity handler to perform resource initialization operations
 116         }
 117         else if (requestFlag == RequestHandlerFlag::RequestFlag)
 118         {
 119             std::cout << "\t\trequestFlag : Request\n";
 120
 121             // If the request type is GET
 122             if (requestType == "GET")
 123             {
 124                 std::cout << "\t\t\trequestType : GET\n";
 125                 // GET operations are directly handled while sending the response
 126                 // in the sendLightResponse function
 127                 result = true;
 128             }
 129             else if (requestType == "PUT")
 130             {
 131                 std::cout << "\t\t\trequestType : PUT\n";
 132                 putFunc putFunction;
 133                 OCRepresentation rep = request->getResourceRepresentation();
 134
 135                 putFunction = getPutFunction(request->getResourceUri());
 136
 137                 // Do related operations related to PUT request
 138                 putFunction(rep);
 139                 result = true;
 140             }
 141             else if (requestType == "POST")
 142             {
 143                 // POST request operations
 144             }
 145             else if (requestType == "DELETE")
 146             {
 147                 // DELETE request operations
 148             }
 149         }
 150         else if (requestFlag == RequestHandlerFlag::ObserverFlag)
 151         {
 152             std::cout << "\t\trequestFlag : Observer\n";
 153         }
 154     }
 155     else
 156     {
 157         std::cout << "Request invalid" << std::endl;
 158     }
 159
 160     return result;
 161 }
 162
 163 OCStackResult sendResponseForResource(std::shared_ptr< OCResourceRequest > pRequest)
 164 {
 165     auto pResponse = std::make_shared< OC::OCResourceResponse >();
 166
 167     // Check for query params (if any)
 168     QueryParamsMap queryParamsMap = pRequest->getQueryParameters();
 169
 170     pResponse->setRequestHandle(pRequest->getRequestHandle());
 171     pResponse->setResourceHandle(pRequest->getResourceHandle());
 172
 173     getFunc getFunction;
 174     getFunction = getGetFunction(pRequest->getResourceUri());
 175
 176     OCRepresentation rep;
 177     rep = getFunction();
 178
 179     auto findRes = queryParamsMap.find("if");
 180
 181     if (findRes != queryParamsMap.end())
 182     {
 183         pResponse->setResourceRepresentation(rep, findRes->second);
 184     }
 185     else
 186     {
 187         pResponse->setResourceRepresentation(rep, DEFAULT_INTERFACE);
 188     }
 189
 190     pResponse->setErrorCode(200);
 191     pResponse->setResponseResult(OC_EH_OK);
 192
 193     return OCPlatform::sendResponse(pResponse);
 194 }
 195
 196 OCEntityHandlerResult entityHandlerForResource(std::shared_ptr< OCResourceRequest > request)
 197 {
 198     std::cout << "\tIn Server CPP (entityHandlerForResource) entity handler:\n";
 199     OCEntityHandlerResult ehResult = OC_EH_ERROR;
 200
 201     QueryParamsMap test = request->getQueryParameters();
 202
 203     if (prepareResponseForResource(request))
 204     {
 205         if (OC_STACK_OK == sendResponseForResource(request))
 206         {
 207             ehResult = OC_EH_OK;
 208         }
 209         else
 210         {
 211             std::cout << "sendResponse failed." << std::endl;
 212         }
 213     }
 214     else
 215     {
 216         std::cout << "PrepareResponse failed." << std::endl;
 217     }
 218     return ehResult;
 219 }
 220
 221 // callback handler on GET request
 222 void onBootstrap(const HeaderOptions& headerOptions, const OCRepresentation& rep, const int eCode)
 223 {
 224     isWaiting = 0;
 225
 226     if (eCode != SUCCESS_RESPONSE)
 227     {
 228         std::cout << "onGET Response error: " << eCode << std::endl;
 229         return ;
 230     }
 231
 232     std::cout << "\n\nGET request was successful" << std::endl;
 233     std::cout << "\tResource URI: " << rep.getUri() << std::endl;
 234
 235     defaultRegion = rep.getValue< std::string >("r");
 236     defaultSystemTime = rep.getValue< std::string >("st");
 237     defaultCurrency = rep.getValue< std::string >("c");
 238     defaultLocation = rep.getValue< std::string >("loc");
 239
 240     std::cout << "\tLocation : " << defaultLocation << std::endl;
 241     std::cout << "\tSystemTime : " << defaultSystemTime << std::endl;
 242     std::cout << "\tCurrency : " << defaultCurrency << std::endl;
 243     std::cout << "\tRegion : " << defaultRegion << std::endl;
 244
 245 }
 246
 247 int main()
 248 {
 249     //**************************************************************
 250     // STEP 0
 251     // Create PlatformConfig object
 252     PlatformConfig cfg
 253     { OC::ServiceType::InProc, OC::ModeType::Both, "0.0.0.0", 0, OC::QualityOfService::LowQos };
 254
 255     OCPlatform::Configure(cfg);
 256     g_thingsmanager = new ThingsManager();
 257     //**************************************************************
 258
 259     if (getuid() != 0)
 260     {
 261         std::cout << "NOTE: You may gain the root privilege (e.g, reboot)\n";
 262         std::cout << "NOTE: Now, you don't have it.\n";
 263     }
 264
 265     try
 266     {
 267         // Perform app tasks
 268         while (true)
 269         {
 270
 271             if (isWaiting > 0)
 272                 continue;
 273
 274             isWaiting = 0;
 275
 276             std::cout << endl << endl << "(0) Quit" << std::endl;
 277             std::cout << "(1) Bootstrap" << std::endl;
 278             std::cout << "(2) Create Configuration Resources" << std::endl;
 279
 280             cin >> g_Steps;
 281             //
 282             if (g_Steps == 0)
 283                 break;
 284             else if (g_Steps == 1)
 285             {
 286                 if( g_thingsmanager->doBootstrap(&onBootstrap) == OC_STACK_OK)
 287                     isWaiting = 1;
 288                 else
 289                     std::cout << "A callback pointer of the function is NULL." << std::endl;
 290             }
 291             else if (g_Steps == 2)
 292             {
 293                 myConfigurationResource = new ConfigurationResource();
 294                 myConfigurationResource->createResources(&entityHandlerForResource);
 295
 296                 myDiagnosticsResource = new DiagnosticsResource();
 297                 myDiagnosticsResource->createResources(&entityHandlerForResource);
 298
 299
 300                 myFactorySetResource = new FactorySetResource();
 301                 myFactorySetResource->createResources(&entityHandlerForResource);
 302                 myDiagnosticsResource->factoryReset = std::function < void()
 303                         > (std::bind(&ConfigurationResource::factoryReset,
 304                                 myConfigurationResource));
 305
 306                 isWaiting = 1;
 307             }
 308         }
 309     }
 310     catch (OCException e)
 311     {
 312         std::cout << "Exception in main: " << e.what();
 313     }
 314
 315     // No explicit call to stop the platform.
 316     // When OCPlatform destructor is invoked, internally we do platform cleanup
 317 }
 318