signal_handler.hpp

// Copyright 2018 Open Source Robotics Foundation, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#ifndef RCLCPP__SIGNAL_HANDLER_HPP_
#define RCLCPP__SIGNAL_HANDLER_HPP_
 
#include <atomic>
#include <csignal>
#include <mutex>
#include <thread>
 
#include "rclcpp/logging.hpp"
#include "rclcpp/utilities.hpp"
 
// includes for semaphore notification code
#if defined(_WIN32)
#include <windows.h>
#elif defined(__APPLE__)
#include <dispatch/dispatch.h>
#else  // posix
#include <semaphore.h>
#endif
 
// Determine if sigaction is available
#if __APPLE__ || _POSIX_C_SOURCE >= 1 || _XOPEN_SOURCE || _POSIX_SOURCE
#define RCLCPP_HAS_SIGACTION
#endif
 
namespace rclcpp
{
 
 
class SignalHandler final
{
public:
  static
  SignalHandler &
  get_global_signal_handler();
 
  static
  rclcpp::Logger &
  get_logger();
 
 
  bool
  install(SignalHandlerOptions signal_handler_options = SignalHandlerOptions::All);
 
 
  bool
  uninstall();
 
  bool
  is_installed();
 
 
  rclcpp::SignalHandlerOptions
  get_current_signal_handler_options();
 
private:
#if defined(RCLCPP_HAS_SIGACTION)
  using signal_handler_type = struct sigaction;
#else
  using signal_handler_type = void (*)(int);
#endif
 
 
  SignalHandler() = default;
 
  ~SignalHandler();
 
  SignalHandler(const SignalHandler &) = delete;
  SignalHandler(SignalHandler &&) = delete;
  SignalHandler &
  operator=(const SignalHandler &) = delete;
  SignalHandler &&
  operator=(SignalHandler &&) = delete;
 
  void
  signal_handler_common();
 
#if defined(RCLCPP_HAS_SIGACTION)
  static
  void
  signal_handler(int signal_value, siginfo_t * siginfo, void * context);
#else
  static
  void
  signal_handler(int signal_value);
#endif
 
  void
  deferred_signal_handler();
 
 
  void
  setup_wait_for_signal();
 
 
  void
  teardown_wait_for_signal() noexcept;
 
 
  void
  wait_for_signal();
 
 
  void
  notify_signal_handler() noexcept;
 
  static
  signal_handler_type
  set_signal_handler(
    int signal_value,
    const signal_handler_type & signal_handler);
 
  signal_handler_type
  get_old_signal_handler(int signum);
 
  rclcpp::SignalHandlerOptions signal_handlers_options_ = rclcpp::SignalHandlerOptions::None;
 
  signal_handler_type old_sigint_handler_;
  signal_handler_type old_sigterm_handler_;
 
  // logger instance
  rclcpp::Logger logger_ = rclcpp::get_logger("rclcpp");
 
  // Whether or not a signal has been received.
  std::atomic_bool signal_received_ = false;
  // A thread to which signal handling tasks are deferred.
  std::thread signal_handler_thread_;
 
  // A mutex used to synchronize the install() and uninstall() methods.
  std::mutex install_mutex_;
  // Whether or not the signal handler has been installed.
  std::atomic_bool installed_ = false;
 
  // Whether or not the semaphore for wait_for_signal is setup.
  std::atomic_bool wait_for_signal_is_setup_;
  // Storage for the wait_for_signal semaphore.
#if defined(_WIN32)
  HANDLE signal_handler_sem_;
#elif defined(__APPLE__)
  dispatch_semaphore_t signal_handler_sem_;
#else  // posix
  sem_t signal_handler_sem_;
#endif
};
 
}  // namespace rclcpp
 
#endif  // RCLCPP__SIGNAL_HANDLER_HPP_