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 = new this._actionServer.typeClass.impl.FeedbackMessage();
  109.     feedbackMessage['goal_id'] = this.goalId;
  110.     feedbackMessage.feedback = feedback;
  112.     rclnodejs.actionPublishFeedback(
  113.       this._actionServer.handle,
  114.       feedbackMessage.serialize()
  115.     );
  116.   }
  118.   /**
  119.    * Updates the goal handle with the succeed status.
  120.    * @returns {undefined}
  121.    */
  122.   succeed() {
  123.     this._updateState(GoalEvent.SUCCEED);
  124.   }
  126.   /**
  127.    * Updates the goal handle with the abort status.
  128.    * @returns {undefined}
  129.    */
  130.   abort() {
  131.     this._updateState(GoalEvent.ABORT);
  132.   }
  134.   /**
  135.    * Updates the goal handle with the canceled status.
  136.    * @returns {undefined}
  137.    */
  138.   canceled() {
  139.     this._updateState(GoalEvent.CANCELED);
  140.   }
  142.   /**
  143.    * Marks the goal handle as destroyed. Any further updates to the handle will be ignored.
  144.    * @ignore
  145.    * @returns {undefined}
  146.    */
  147.   destroy() {
  148.     if (this._destroyed) {
  149.       return;
  150.     }
  152.     this._destroyed = true;
  153.   }
  155.   _updateState(event) {
  156.     // Ignore updates for already destroyed goal handles
  157.     if (this._destroyed) {
  158.       return;
  159.     }
  161.     // Update state
  162.     rclnodejs.actionUpdateGoalState(this._handle, event);
  164.     // Publish state change
  165.     rclnodejs.actionPublishStatus(this._actionServer.handle);
  167.     // If it's a terminal state, then also notify the action server
  168.     if (!rclnodejs.actionGoalHandleIsActive(this._handle)) {
  169.       rclnodejs.actionNotifyGoalDone(this._actionServer.handle);
  170.     }
  171.   }
  172. }
  174. module.exports = ServerGoalHandle;