Source: lib/client.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:client');
  21. /**
  22.  * @class - Class representing a Client in ROS
  23.  * @hideconstructor
  24.  */
  26. class Client extends Entity {
  27.   constructor(handle, nodeHandle, serviceName, typeClass, options) {
  28.     super(handle, typeClass, options);
  29.     this._nodeHandle = nodeHandle;
  30.     this._serviceName = serviceName;
  31.     this._sequenceNumber = 0;
  32.   }
  34.   /**
  35.    * This callback is called when a resopnse is sent back from service
  36.    * @callback ResponseCallback
  37.    * @param {Object} response - The response sent from the service
  38.    * @see [Client.sendRequest]{@link Client#sendRequest}
  39.    * @see [Node.createService]{@link Node#createService}
  40.    * @see {@link Client}
  41.    * @see {@link Service}
  42.    */
  44.   /**
  45.    * Send the request and will be notified asynchronously if receiving the repsonse.
  46.    * @param {object} request - The request to be submitted.
  47.    * @param {ResponseCallback} callback - Thc callback function for receiving the server response.
  48.    * @return {undefined}
  49.    * @see {@link ResponseCallback}
  50.    */
  51.   sendRequest(request, callback) {
  52.     let requestToSend =
  53.       request instanceof this._typeClass.Request
  54.         ? request
  55.         : new this._typeClass.Request(request);
  56.     if (typeof callback !== 'function') {
  57.       throw new TypeError('Invalid argument');
  58.     }
  60.     let rawRequest = requestToSend.serialize();
  61.     this._sequenceNumber = rclnodejs.sendRequest(this._handle, rawRequest);
  62.     debug(`Client has sent a ${this._serviceName} request.`);
  63.     this._callback = callback;
  64.   }
  66.   get sequenceNumber() {
  67.     return this._sequenceNumber;
  68.   }
  70.   processResponse(response) {
  71.     debug(`Client has received ${this._serviceName} response from service.`);
  72.     this._callback(response.toPlainObject(this.typedArrayEnabled));
  73.   }
  75.   /**
  76.    * Checks if the service is available.
  77.    * @return {boolean} true if the service is available.
  78.    */
  79.   isServiceServerAvailable() {
  80.     return rclnodejs.serviceServerIsAvailable(this._nodeHandle, this.handle);
  81.   }
  83.   /**
  84.    * Wait until the service server is available or a timeout is reached. This
  85.    * function polls for the service state so it may not return as soon as the
  86.    * service is available.
  87.    * @param {number} timeout The maximum amount of time to wait for, if timeout
  88.    * is `undefined` or `< 0`, this will wait indefinitely.
  89.    * @return {Promise<boolean>} true if the service is available.
  90.    */
  91.   async waitForService(timeout = undefined) {
  92.     let deadline = Infinity;
  93.     if (timeout !== undefined && timeout >= 0) {
  94.       deadline = Date.now() + timeout;
  95.     }
  96.     let waitMs = 5;
  97.     let serviceAvailable = this.isServiceServerAvailable();
  98.     while (!serviceAvailable && Date.now() < deadline) {
  99.       waitMs *= 2;
  100.       waitMs = Math.min(waitMs, 1000);
  101.       if (timeout !== undefined && timeout >= -1) {
  102.         waitMs = Math.min(waitMs, deadline - Date.now());
  103.       }
  104.       await new Promise(resolve => setTimeout(resolve, waitMs));
  105.       serviceAvailable = this.isServiceServerAvailable();
  106.     }
  107.     return serviceAvailable;
  108.   }
  110.   static createClient(nodeHandle, serviceName, typeClass, options) {
  111.     let type = typeClass.type();
  112.     let handle = rclnodejs.createClient(
  113.       nodeHandle,
  114.       serviceName,
  115.       type.interfaceName,
  116.       type.pkgName,
  117.       options.qos
  118.     );
  119.     return new Client(handle, nodeHandle, serviceName, typeClass, options);
  120.   }
  122.   /**
  123.    * @type {string}
  124.    */
  125.   get serviceName() {
  126.     return this._serviceName;
  127.   }
  128. }
  130. module.exports = Client;