Source: lib/service.js

  1. // Copyright (c) 2017 Intel Corporation. All rights reserved.
  2. //
  3. // Licensed under the Apache License, Version 2.0 (the "License");
  4. // you may not use this file except in compliance with the License.
  5. // You may obtain a copy of the License at
  6. //
  7. //     http://www.apache.org/licenses/LICENSE-2.0
  8. //
  9. // Unless required by applicable law or agreed to in writing, software
  10. // distributed under the License is distributed on an "AS IS" BASIS,
  11. // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12. // See the License for the specific language governing permissions and
  13. // limitations under the License.
  15. 'use strict';
  17. const rclnodejs = require('bindings')('rclnodejs');
  18. const Entity = require('./entity.js');
  19. const debug = require('debug')('rclnodejs:service');
  21. /**
  22.  * The response to client
  23.  *
  24.  * @property {Object} template - Get an empty response object that is being sent to client.
  25.  * @property {Service} service - The service that this response object is attaching to.
  26.  *
  27.  * @hideconstructor
  28.  */
  29. class Response {
  30.   constructor(service, header) {
  31.     this._service = service;
  32.     this._header = header;
  33.     this.sent = false;
  34.   }
  36.   get template() {
  37.     let response = new this._service._typeClass.Response();
  38.     return response.toPlainObject();
  39.   }
  41.   get service() {
  42.     return this._service;
  43.   }
  45.   /**
  46.    * Send response to client (the service caller)
  47.    * @param {object} response - The plain JavaScript representing the response.
  48.         Note: you can use .template to get an empty result object.
  49.    * @return {undefined}
  50.    * @see {@link Response#template}
  51.    */
  52.   send(response) {
  53.     let responseToReturn = new this._service._typeClass.Response(response);
  54.     const rawResponse = responseToReturn.serialize();
  55.     rclnodejs.sendResponse(this._service._handle, rawResponse, this._header);
  56.     this.sent = true;
  57.   }
  58. }
  60. /**
  61.  * @class - Class representing a Service in ROS
  62.  * @hideconstructor
  63.  */
  65. class Service extends Entity {
  66.   constructor(handle, serviceName, typeClass, options, callback) {
  67.     super(handle, typeClass, options);
  68.     this._callback = callback;
  69.   }
  71.   processRequest(headerHandle, request) {
  72.     debug(`Service has received a ${this._serviceName} request from client.`);
  74.     const plainObj = request.toPlainObject(this.typedArrayEnabled);
  75.     const response = new Response(this, headerHandle);
  76.     let responseToReturn = this._callback(plainObj, response);
  78.     if (!response.sent && responseToReturn) {
  79.       responseToReturn = new this._typeClass.Response(responseToReturn);
  80.       const rawResponse = responseToReturn.serialize();
  81.       rclnodejs.sendResponse(this._handle, rawResponse, headerHandle);
  82.     }
  84.     debug(
  85.       `Service has processed the ${this._serviceName} request and sent the response.`
  86.     );
  87.   }
  89.   static createService(nodeHandle, serviceName, typeClass, options, callback) {
  90.     let type = typeClass.type();
  91.     let handle = rclnodejs.createService(
  92.       nodeHandle,
  93.       serviceName,
  94.       type.interfaceName,
  95.       type.pkgName,
  96.       options.qos
  97.     );
  98.     return new Service(handle, serviceName, typeClass, options, callback);
  99.   }
  101.   /**
  102.    * @type {string}
  103.    */
  104.   get serviceName() {
  105.     const fullServiceName = rclnodejs.getServiceName(this._handle); // returns /my_node/myservice
  106.     return fullServiceName.split('/').pop();
  107.   }
  108. }
  110. module.exports = Service;