Source: lib/action/server_goal_handle.js

  1. // Copyright (c) 2020 Matt Richard. 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 ActionInterfaces = require('./interfaces.js');
  19. const Deferred = require('./deferred.js');
  20. const { GoalEvent } = require('./response.js');
  22. /**
  23.  * @class - Goal handle for working with Action Servers.
  24.  * @hideconstructor
  25.  */
  27. class ServerGoalHandle {
  28.   constructor(actionServer, goalInfo, goalRequest) {
  29.     this._actionServer = actionServer;
  30.     this._goalInfo = goalInfo;
  31.     this._goalRequest = goalRequest;
  32.     this._cancelRequested = false;
  33.     this._deferred = new Deferred();
  35.     this._handle = rclnodejs.actionAcceptNewGoal(
  36.       this._actionServer.handle,
  37.       this._goalInfo.serialize()
  38.     );
  39.   }
  41.   /**
  42.    * Gets the goal request.
  43.    */
  44.   get request() {
  45.     return this._goalRequest;
  46.   }
  48.   /**
  49.    * Gets the goal Id.
  50.    */
  51.   get goalId() {
  52.     return this._goalInfo.goal_id;
  53.   }
  55.   /**
  56.    * Gets if the goal handle is active.
  57.    */
  58.   get isActive() {
  59.     if (this._destroyed) {
  60.       return false;
  61.     }
  63.     return rclnodejs.actionGoalHandleIsActive(this._handle);
  64.   }
  66.   /**
  67.    * Gets if cancellation was requested.
  68.    */
  69.   get isCancelRequested() {
  70.     return this.status === ActionInterfaces.GoalStatus.STATUS_CANCELING;
  71.   }
  73.   /**
  74.    * Gets the status of the goal.
  75.    */
  76.   get status() {
  77.     if (this._destroyed) {
  78.       return ActionInterfaces.GoalStatus.STATUS_UNKNOWN;
  79.     }
  81.     return rclnodejs.actionGoalHandleGetStatus(this._handle);
  82.   }
  84.   /**
  85.    * Updates the goal handle with the execute status and begins exection.
  86.    * @param {function} callback - An optional callback to use instead of the one provided to the action server.
  87.    * @returns {undefined}
  88.    */
  89.   execute(callback) {
  90.     if (!this.isCancelRequested) {
  91.       this._updateState(GoalEvent.EXECUTE);
  92.     }
  94.     this._actionServer.notifyExecute(this, callback);
  95.   }
  97.   /**
  98.    * Sends feedback back to the client.
  99.    * @param {object} feedback - The feedback to send back.
  100.    * @returns {undefined}
  101.    */
  102.   publishFeedback(feedback) {
  103.     // Ignore for already destroyed goal handles
  104.     if (this._destroyed) {
  105.       return;
  106.     }
  108.     let feedbackMessage =
  109.       new this._actionServer.typeClass.impl.FeedbackMessage();
  110.     feedbackMessage['goal_id'] = this.goalId;
  111.     feedbackMessage.feedback = feedback;
  113.     rclnodejs.actionPublishFeedback(
  114.       this._actionServer.handle,
  115.       feedbackMessage.serialize()
  116.     );
  117.   }
  119.   /**
  120.    * Updates the goal handle with the succeed status.
  121.    * @returns {undefined}
  122.    */
  123.   succeed() {
  124.     this._updateState(GoalEvent.SUCCEED);
  125.   }
  127.   /**
  128.    * Updates the goal handle with the abort status.
  129.    * @returns {undefined}
  130.    */
  131.   abort() {
  132.     this._updateState(GoalEvent.ABORT);
  133.   }
  135.   /**
  136.    * Updates the goal handle with the canceled status.
  137.    * @returns {undefined}
  138.    */
  139.   canceled() {
  140.     this._updateState(GoalEvent.CANCELED);
  141.   }
  143.   /**
  144.    * Marks the goal handle as destroyed. Any further updates to the handle will be ignored.
  145.    * @ignore
  146.    * @returns {undefined}
  147.    */
  148.   destroy() {
  149.     if (this._destroyed) {
  150.       return;
  151.     }
  153.     this._destroyed = true;
  154.   }
  156.   _updateState(event) {
  157.     // Ignore updates for already destroyed goal handles
  158.     if (this._destroyed) {
  159.       return;
  160.     }
  162.     // Update state
  163.     rclnodejs.actionUpdateGoalState(this._handle, event);
  165.     // Publish state change
  166.     rclnodejs.actionPublishStatus(this._actionServer.handle);
  168.     // If it's a terminal state, then also notify the action server
  169.     if (!rclnodejs.actionGoalHandleIsActive(this._handle)) {
  170.       rclnodejs.actionNotifyGoalDone(this._actionServer.handle);
  171.     }
  172.   }
  173. }
  175. module.exports = ServerGoalHandle;