cloud/interface/src/main/java/org/iotivity/cloud/ciserver/DeviceServerSystem.java

   1 /*
   2  * //******************************************************************
   3  * //
   4  * // Copyright 2016 Samsung Electronics All Rights Reserved.
   5  * //
   6  * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   7  * //
   8  * // Licensed under the Apache License, Version 2.0 (the "License");
   9  * // you may not use this file except in compliance with the License.
  10  * // You may obtain a copy of the License at
  11  * //
  12  * //      http://www.apache.org/licenses/LICENSE-2.0
  13  * //
  14  * // Unless required by applicable law or agreed to in writing, software
  15  * // distributed under the License is distributed on an "AS IS" BASIS,
  16  * // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * // See the License for the specific language governing permissions and
  18  * // limitations under the License.
  19  * //
  20  * //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  21  */
  22 package org.iotivity.cloud.ciserver;
  23
  24 import java.util.HashMap;
  25 import java.util.Iterator;
  26
  27 import org.iotivity.cloud.base.OICConstants;
  28 import org.iotivity.cloud.base.ServerSystem;
  29 import org.iotivity.cloud.base.connector.ConnectorPool;
  30 import org.iotivity.cloud.base.device.CoapDevice;
  31 import org.iotivity.cloud.base.device.Device;
  32 import org.iotivity.cloud.base.device.IRequestChannel;
  33 import org.iotivity.cloud.base.exception.ClientException;
  34 import org.iotivity.cloud.base.exception.ServerException;
  35 import org.iotivity.cloud.base.exception.ServerException.BadOptionException;
  36 import org.iotivity.cloud.base.exception.ServerException.BadRequestException;
  37 import org.iotivity.cloud.base.exception.ServerException.UnAuthorizedException;
  38 import org.iotivity.cloud.base.protocols.MessageBuilder;
  39 import org.iotivity.cloud.base.protocols.coap.CoapRequest;
  40 import org.iotivity.cloud.base.protocols.coap.CoapResponse;
  41 import org.iotivity.cloud.base.protocols.coap.CoapSignaling;
  42 import org.iotivity.cloud.base.protocols.enums.ContentFormat;
  43 import org.iotivity.cloud.base.protocols.enums.RequestMethod;
  44 import org.iotivity.cloud.base.protocols.enums.ResponseStatus;
  45 import org.iotivity.cloud.base.protocols.enums.SignalingMethod;
  46 import org.iotivity.cloud.base.server.CoapServer;
  47 import org.iotivity.cloud.base.server.HttpServer;
  48 import org.iotivity.cloud.base.server.Server;
  49 import org.iotivity.cloud.base.server.WebSocketServer;
  50 import org.iotivity.cloud.util.Bytes;
  51 import org.iotivity.cloud.util.Cbor;
  52 import org.iotivity.cloud.util.Log;
  53
  54 import io.netty.channel.ChannelDuplexHandler;
  55 import io.netty.channel.ChannelHandler.Sharable;
  56 import io.netty.channel.ChannelHandlerContext;
  57 import io.netty.channel.ChannelInboundHandlerAdapter;
  58 import io.netty.channel.ChannelPromise;
  59
  60 /**
  61  *
  62  * This class provides a set of APIs to manage all of request
  63  *
  64  */
  65
  66 public class DeviceServerSystem extends ServerSystem {
  67
  68     private Cbor<HashMap<String, Object>>                 mCbor     = new Cbor<HashMap<String, Object>>();
  69     private HashMap<ChannelHandlerContext, CoapSignaling> mCsmMap   = new HashMap<>();
  70
  71     IRequestChannel                                       mRDServer = null;
  72
  73     public DeviceServerSystem() {
  74         mRDServer = ConnectorPool.getConnection("rd");
  75     }
  76
  77     /**
  78      *
  79      * This class provides a set of APIs to manage device pool.
  80      *
  81      */
  82     public class CoapDevicePool {
  83         HashMap<String, Device> mMapDevice = new HashMap<>();
  84
  85         /**
  86          * API for adding device information into pool.
  87          *
  88          * @param device
  89          *            device to be added
  90          */
  91         public void addDevice(Device device) {
  92             String deviceId = ((CoapDevice) device).getDeviceId();
  93             synchronized (mMapDevice) {
  94                 mMapDevice.put(deviceId, device);
  95             }
  96         }
  97
  98         /**
  99          * API for removing device information into pool.
 100          *
 101          * @param device
 102          *            device to be removed
 103          */
 104         public void removeDevice(Device device) throws ClientException {
 105             String deviceId = ((CoapDevice) device).getDeviceId();
 106             synchronized (mMapDevice) {
 107                 if (mMapDevice.get(deviceId) == device) {
 108                     mMapDevice.remove(deviceId);
 109                 }
 110             }
 111             removeObserveDevice(device);
 112         }
 113
 114         private void removeObserveDevice(Device device) throws ClientException {
 115             Iterator<String> iterator = mMapDevice.keySet().iterator();
 116             while (iterator.hasNext()) {
 117                 String deviceId = iterator.next();
 118                 CoapDevice getDevice = (CoapDevice) queryDevice(deviceId);
 119                 getDevice.removeObserveChannel(
 120                         ((CoapDevice) device).getRequestChannel());
 121             }
 122         }
 123
 124         /**
 125          * API for getting device information.
 126          *
 127          * @param deviceId
 128          *            device id to get device
 129          */
 130         public Device queryDevice(String deviceId) {
 131             Device device = null;
 132             synchronized (mMapDevice) {
 133                 device = mMapDevice.get(deviceId);
 134             }
 135             return device;
 136         }
 137     }
 138
 139     CoapDevicePool mDevicePool = new CoapDevicePool();
 140
 141     /**
 142      *
 143      * This class provides a set of APIs to manage life cycle of coap message.
 144      *
 145      */
 146     @Sharable
 147     class CoapLifecycleHandler extends ChannelDuplexHandler {
 148         @Override
 149         public void channelRead(ChannelHandlerContext ctx, Object msg) {
 150
 151             if (msg instanceof CoapRequest) {
 152                 try {
 153                     CoapDevice coapDevice = (CoapDevice) ctx.channel()
 154                             .attr(keyDevice).get();
 155
 156                     if (coapDevice.isExpiredTime()) {
 157                         throw new UnAuthorizedException("token is expired");
 158                     }
 159
 160                     CoapRequest coapRequest = (CoapRequest) msg;
 161                     IRequestChannel targetChannel = null;
 162                     if (coapRequest.getUriPath()
 163                             .contains(Constants.ROUTE_FULL_URI)) {
 164
 165                         int RouteResourcePathSize = Constants.ROUTE_FULL_URI
 166                                 .split("/").length;
 167                         CoapDevice targetDevice = (CoapDevice) mDevicePool
 168                                 .queryDevice(coapRequest.getUriPathSegments()
 169                                         .get(RouteResourcePathSize - 1));
 170                         targetChannel = targetDevice.getRequestChannel();
 171                     }
 172                     switch (coapRequest.getObserve()) {
 173                         case SUBSCRIBE:
 174                             coapDevice.addObserveRequest(
 175                                     Bytes.bytesToLong(coapRequest.getToken()),
 176                                     coapRequest);
 177                             coapDevice.addObserveChannel(targetChannel);
 178                             break;
 179                         case UNSUBSCRIBE:
 180                             coapDevice.removeObserveChannel(targetChannel);
 181                             coapDevice.removeObserveRequest(
 182                                     Bytes.bytesToLong(coapRequest.getToken()));
 183                             break;
 184                         default:
 185                             break;
 186                     }
 187
 188                 } catch (Throwable t) {
 189                     Log.f(ctx.channel(), t);
 190                     ResponseStatus responseStatus = t instanceof ServerException
 191                             ? ((ServerException) t).getErrorResponse()
 192                             : ResponseStatus.INTERNAL_SERVER_ERROR;
 193                     ctx.writeAndFlush(MessageBuilder
 194                             .createResponse((CoapRequest) msg, responseStatus));
 195                     ctx.close();
 196                 }
 197             }
 198             ctx.fireChannelRead(msg);
 199         }
 200
 201         @Override
 202         public void write(ChannelHandlerContext ctx, Object msg,
 203                 ChannelPromise promise) throws Exception {
 204
 205             boolean bCloseConnection = false;
 206
 207             if (msg instanceof CoapResponse) {
 208                 // This is CoapResponse
 209                 // Once the response is valid, add this to deviceList
 210                 CoapResponse response = (CoapResponse) msg;
 211
 212                 switch (response.getUriPath()) {
 213                     case OICConstants.ACCOUNT_SESSION_FULL_URI:
 214                         if (response.getStatus() != ResponseStatus.CHANGED) {
 215                             bCloseConnection = true;
 216                         }
 217                         break;
 218                     case OICConstants.ACCOUNT_FULL_URI:
 219                         if (response.getStatus() == ResponseStatus.DELETED) {
 220                             bCloseConnection = true;
 221                         }
 222                         break;
 223                 }
 224             }
 225
 226             ctx.writeAndFlush(msg);
 227
 228             if (bCloseConnection == true) {
 229                 ctx.close();
 230             }
 231         }
 232
 233         @Override
 234         public void channelActive(ChannelHandlerContext ctx) {
 235             Device device = ctx.channel().attr(keyDevice).get();
 236             // Authenticated device connected
 237
 238             sendDevicePresence(device.getDeviceId(), "on");
 239             mDevicePool.addDevice(device);
 240
 241             device.onConnected();
 242         }
 243
 244         @Override
 245         public void channelInactive(ChannelHandlerContext ctx)
 246                 throws ClientException {
 247             Device device = ctx.channel().attr(keyDevice).get();
 248
 249             // Some cases, this event occurs after new device connected using
 250             // same di.
 251             // So compare actual value, and remove if same.
 252             if (device != null) {
 253                 sendDevicePresence(device.getDeviceId(), "off");
 254
 255                 device.onDisconnected();
 256
 257                 mDevicePool.removeDevice(device);
 258                 ctx.channel().attr(keyDevice).remove();
 259
 260             }
 261         }
 262
 263         /**
 264          * API for sending state to resource directory
 265          *
 266          * @param deviceId
 267          *            device id to be sent to resource directory
 268          * @param state
 269          *            device state to be sent to resource directory
 270          */
 271         public void sendDevicePresence(String deviceId, String state) {
 272
 273             Cbor<HashMap<String, Object>> cbor = new Cbor<>();
 274             HashMap<String, Object> payload = new HashMap<String, Object>();
 275             payload.put(Constants.REQ_DEVICE_ID, deviceId);
 276             payload.put(Constants.PRESENCE_STATE, state);
 277             StringBuffer uriPath = new StringBuffer();
 278             uriPath.append("/" + Constants.PREFIX_OIC);
 279             uriPath.append("/" + Constants.DEVICE_PRESENCE_URI);
 280             mRDServer.sendRequest(MessageBuilder.createRequest(
 281                     RequestMethod.POST, uriPath.toString(), null,
 282                     ContentFormat.APPLICATION_CBOR,
 283                     cbor.encodingPayloadToCbor(payload)), null);
 284         }
 285     }
 286
 287     CoapLifecycleHandler mLifeCycleHandler = new CoapLifecycleHandler();
 288
 289     @Sharable
 290     class CoapAuthHandler extends ChannelDuplexHandler {
 291
 292         @Override
 293         public void channelActive(ChannelHandlerContext ctx) {
 294             // Actual channel active should decided after authentication.
 295         }
 296
 297         @Override
 298         public void write(ChannelHandlerContext ctx, Object msg,
 299                 ChannelPromise promise) {
 300             try {
 301
 302                 if (!(msg instanceof CoapResponse)) {
 303                     // throw new BadRequestException(
 304                     // "this msg type is not CoapResponse");
 305
 306                     // TODO check websocket handshake response
 307                     ctx.writeAndFlush(msg);
 308                     return;
 309                 }
 310                 // This is CoapResponse
 311                 // Once the response is valid, add this to deviceList
 312
 313                 CoapResponse response = (CoapResponse) msg;
 314
 315                 switch (response.getUriPath()) {
 316
 317                     case OICConstants.ACCOUNT_SESSION_FULL_URI:
 318                         HashMap<String, Object> payloadData = mCbor
 319                                 .parsePayloadFromCbor(response.getPayload(),
 320                                         HashMap.class);
 321
 322                         if (response.getStatus() != ResponseStatus.CHANGED) {
 323                             throw new UnAuthorizedException();
 324                         }
 325
 326                         if (payloadData == null) {
 327                             throw new BadRequestException("payload is empty");
 328                         }
 329                         int remainTime = (int) payloadData
 330                                 .get(Constants.EXPIRES_IN);
 331
 332                         Device device = ctx.channel().attr(keyDevice).get();
 333                         ((CoapDevice) device).setExpiredPolicy(remainTime);
 334
 335                         // Remove current auth handler and replace to
 336                         // LifeCycleHandle
 337                         ctx.channel().pipeline().replace(this,
 338                                 "LifeCycleHandler", mLifeCycleHandler);
 339
 340                         // Raise event that we have Authenticated device
 341                         ctx.fireChannelActive();
 342
 343                         break;
 344                 }
 345
 346                 ctx.writeAndFlush(msg);
 347
 348             } catch (Throwable t) {
 349                 Log.f(ctx.channel(), t);
 350                 ctx.writeAndFlush(msg);
 351                 ctx.close();
 352             }
 353         }
 354
 355         @Override
 356         public void channelRead(ChannelHandlerContext ctx, Object msg) {
 357             try {
 358                 if (!(msg instanceof CoapRequest)) {
 359                     throw new BadRequestException(
 360                             "this msg type is not CoapRequest");
 361                 }
 362
 363                 // And check first response is VALID then add or cut
 364                 CoapRequest request = (CoapRequest) msg;
 365
 366                 switch (request.getUriPath()) {
 367                     // Check whether request is about account
 368                     case OICConstants.ACCOUNT_FULL_URI:
 369                     case OICConstants.ACCOUNT_TOKENREFRESH_FULL_URI:
 370
 371                         if (ctx.channel().attr(keyDevice).get() == null) {
 372                             // Create device first and pass to upperlayer
 373                             Device device = new CoapDevice(ctx);
 374                             ctx.channel().attr(keyDevice).set(device);
 375                         }
 376
 377                         break;
 378
 379                     case OICConstants.ACCOUNT_SESSION_FULL_URI:
 380
 381                         HashMap<String, Object> authPayload = mCbor
 382                                 .parsePayloadFromCbor(request.getPayload(),
 383                                         HashMap.class);
 384
 385                         Device device = ctx.channel().attr(keyDevice).get();
 386
 387                         if (device == null) {
 388                             device = new CoapDevice(ctx);
 389                             ctx.channel().attr(keyDevice).set(device);
 390                         }
 391
 392                         if (authPayload == null) {
 393                             throw new BadRequestException("payload is empty");
 394                         }
 395
 396                         ((CoapDevice) device).updateDevice(
 397                                 (String) authPayload.get(Constants.DEVICE_ID),
 398                                 (String) authPayload.get(Constants.USER_ID),
 399                                 (String) authPayload
 400                                         .get(Constants.ACCESS_TOKEN));
 401
 402                         break;
 403
 404                     case OICConstants.KEEP_ALIVE_FULL_URI:
 405                         // TODO: Pass ping request to upper layer
 406                         break;
 407
 408                     default:
 409                         throw new UnAuthorizedException(
 410                                 "authentication required first");
 411                 }
 412
 413                 ctx.fireChannelRead(msg);
 414
 415             } catch (Throwable t) {
 416                 ResponseStatus responseStatus = t instanceof ServerException
 417                         ? ((ServerException) t).getErrorResponse()
 418                         : ResponseStatus.UNAUTHORIZED;
 419                 ctx.writeAndFlush(MessageBuilder
 420                         .createResponse((CoapRequest) msg, responseStatus));
 421                 Log.f(ctx.channel(), t);
 422             }
 423         }
 424     }
 425
 426     @Sharable
 427     class HttpAuthHandler extends ChannelDuplexHandler {
 428         @Override
 429         public void channelActive(ChannelHandlerContext ctx) throws Exception {
 430             // After current channel authenticated, raise to upper layer
 431         }
 432     }
 433
 434     @Sharable
 435     class CoapSignalingHandler extends ChannelInboundHandlerAdapter {
 436
 437         @Override
 438         public void channelInactive(ChannelHandlerContext ctx)
 439                 throws Exception {
 440             // delete csm information from the map
 441             mCsmMap.remove(ctx);
 442             ctx.fireChannelInactive();
 443         }
 444
 445         @Override
 446         public void channelRead(ChannelHandlerContext ctx, Object msg) {
 447             try {
 448                 if (msg instanceof CoapSignaling) {
 449                     if (mCsmMap.get(ctx) == null) {
 450                         // In the server, the CSM message is sent to the device
 451                         // once
 452                         CoapSignaling inicialCsm = (CoapSignaling) MessageBuilder
 453                                 .createSignaling(SignalingMethod.CSM);
 454                         inicialCsm.setCsmMaxMessageSize(4294967295L);
 455                         ctx.writeAndFlush(inicialCsm);
 456                     }
 457                     CoapSignaling signaling = (CoapSignaling) msg;
 458                     switch (signaling.getSignalingMethod()) {
 459                         case CSM:
 460                             // get existing CSM from the map
 461                             CoapSignaling existingCsm = mCsmMap.get(ctx);
 462                             if (existingCsm == null) {
 463                                 existingCsm = signaling;
 464                             } else {
 465                                 // replace and cumulate CSM options
 466                                 existingCsm.setCsmBlockWiseTransfer(
 467                                         signaling.getCsmBlockWiseTransfer());
 468                                 existingCsm.setCsmMaxMessageSize(
 469                                         signaling.getCsmMaxMessageSize());
 470                                 existingCsm.setCsmServerName(
 471                                         signaling.getCsmServerName());
 472                             }
 473                             mCsmMap.put(ctx, existingCsm);
 474                             break;
 475                         case PING:
 476                             // TODO process PING signaling option
 477                             break;
 478                         case PONG:
 479                             // TODO process PONG signaling option
 480                             break;
 481                         case RELEASE:
 482                         case ABORT:
 483                             mCsmMap.remove(ctx);
 484                             ctx.close();
 485                             break;
 486                         default:
 487                             throw new BadOptionException(
 488                                     "unsupported CoAP Signaling option");
 489                     }
 490
 491                     ctx.fireChannelRead(msg);
 492                 } else {
 493                     ctx.fireChannelRead(msg);
 494                     // TODO annotated codes must be removed to follow
 495                     // the CSM specification of draft-ietf-core-coap-tcp-tls-05
 496
 497                     // if (mCsmMap.get(ctx) != null) {
 498                     // ctx.fireChannelRead(msg);
 499                     // } else {
 500                     // // send ABORT signaling and close the connection
 501                     // ctx.writeAndFlush(MessageBuilder.createSignaling(
 502                     // SignalingMethod.ABORT,
 503                     // new String(
 504                     // "Capability and Settings message (CSM) is not received
 505                     // yet")
 506                     // .getBytes()));
 507                     // ctx.close();
 508                     // }
 509                 }
 510             } catch (Throwable t) {
 511                 ResponseStatus responseStatus = t instanceof ServerException
 512                         ? ((ServerException) t).getErrorResponse()
 513                         : ResponseStatus.BAD_OPTION;
 514                 if (msg instanceof CoapRequest) {
 515                     ctx.writeAndFlush(MessageBuilder
 516                             .createResponse((CoapRequest) msg, responseStatus));
 517                 } else if (msg instanceof CoapSignaling) {
 518                     ctx.writeAndFlush(MessageBuilder.createSignalingResponse(
 519                             (CoapSignaling) msg, responseStatus));
 520                 }
 521                 Log.f(ctx.channel(), t);
 522             }
 523         }
 524
 525     }
 526
 527     @Override
 528     public void addServer(Server server) {
 529         if (server instanceof CoapServer) {
 530             server.addHandler(new CoapSignalingHandler());
 531             server.addHandler(new CoapAuthHandler());
 532         }
 533
 534         if (server instanceof WebSocketServer) {
 535             server.addHandler(new CoapAuthHandler());
 536         }
 537
 538         if (server instanceof HttpServer) {
 539             server.addHandler(new HttpAuthHandler());
 540         }
 541
 542         super.addServer(server);
 543     }
 544
 545     public CoapDevicePool getDevicePool() {
 546         return mDevicePool;
 547     }
 548 }