Merge remote-tracking branch 'origin/develop' into feature/boost_datetime_implementation

5 files changed, 230 insertions, 4 deletions

diff --git a/src/components/utils/CMakeLists.txt b/src/components/utils/CMakeLists.txt
index 25d423ad55..9db1312844 100644
--- a/src/components/utils/CMakeLists.txt
+++ b/src/components/utils/CMakeLists.txt
@@ -40,6 +40,7 @@ include_directories (
   ${COMPONENTS_DIR}/protocol_handler/include
   ${JSONCPP_INCLUDE_DIRECTORY}
   ${LOG4CXX_INCLUDE_DIRECTORY}
+  ${CMAKE_SOURCE_DIR}/src
 )
 
 # dbms
diff --git a/src/components/utils/include/utils/signals.h b/src/components/utils/include/utils/signals.h
index 72d29a9e28..bda83f315f 100644
--- a/src/components/utils/include/utils/signals.h
+++ b/src/components/utils/include/utils/signals.h
@@ -38,11 +38,61 @@ typedef void (*sighandler_t)(int);
 #else
 #include <signal.h>
 #endif
+#include "appMain/low_voltage_signals_handler.h"
 
 namespace utils {
 
-bool UnsibscribeFromTermination();
-bool WaitTerminationSignals(sighandler_t sig_handler);
+class Signals {
+ public:
+  /**
+   * @brief Unsubscribe thread from termination signals SIGINT and SIGTERM
+   * @return True if thread unsubscribed successfuly, otherwise false
+   */
+  static bool UnsubscribeFromTermination();
+
+  /**
+   * @brief Triggers thread to wait for termination signals SIGINT and SIGTERM
+   * @param sig_handler - handler to work with signals specidied above
+   * @return True if handler handles signals successfuly, otherwise false
+   */
+  static bool WaitTerminationSignals(sighandler_t sig_handler);
+
+  /**
+   * @brief Unsubscribe thread from low voltage signals
+   *  SIGLOWVOLTAGE, SIGWAKEUP and SIGIGNOFF
+   * @return True if thread unsubscribed successfuly, otherwise false
+   */
+  static bool UnsubscribeFromLowVoltageSignals(
+      const main_namespace::LowVoltageSignalsOffset& offset_data);
+
+  /**
+   * @brief Sends signal to specified process
+   * @param signal to send
+   * @param destination process signal to be sent to
+   */
+  static void SendSignal(const int signo, const pid_t pid);
+
+  /**
+   * @brief Creates child process
+   * @return created process id or -1 in case of error
+   */
+  static pid_t Fork();
+
+  /**
+   * @brief Wait for child process to be terminated
+   * @param cpid - process to wait for termination
+   * @param status store status information in the int to which it points
+   * @param options - options for exit form function
+   * detailed options can be found here: https://linux.die.net/man/2/waitpid
+   */
+  static void WaitPid(pid_t cpid, int* status, int options);
+
+  /**
+   * @brief Exits for process
+   * @param status - exit status code
+   */
+  static void ExitProcess(const int status);
+};
 
 }  //  namespace utils
 
diff --git a/src/components/utils/src/signals_posix.cc b/src/components/utils/src/signals_posix.cc
index 274c254716..e13dc04f40 100644
--- a/src/components/utils/src/signals_posix.cc
+++ b/src/components/utils/src/signals_posix.cc
@@ -29,13 +29,16 @@
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
+#include <sys/wait.h>
 #include <csignal>
 #include <cstdlib>
 #include <stdint.h>
+#include <iostream>
 
 #include "utils/signals.h"
 
-bool utils::UnsibscribeFromTermination() {
+namespace utils {
+bool Signals::UnsubscribeFromTermination() {
   // Disable some system signals receiving in thread
   // by blocking those signals
   // (system signals processes only in the main thread)
@@ -51,6 +54,42 @@ bool utils::UnsibscribeFromTermination() {
   return !pthread_sigmask(SIG_BLOCK, &signal_set, NULL);
 }
 
+bool Signals::UnsubscribeFromLowVoltageSignals(
+    const main_namespace::LowVoltageSignalsOffset& offset_data) {
+  // Disable Low Voltage signals in main thread
+  // due to all further threads will inherit signals mask
+  sigset_t signal_set;
+  sigemptyset(&signal_set);
+  const int SIGLOWVOLTAGE = SIGRTMIN + offset_data.low_voltage_signal_offset;
+  const int SIGWAKEUP = SIGRTMIN + offset_data.wake_up_signal_offset;
+  const int SIGIGNOFF = SIGRTMIN + offset_data.ignition_off_signal_offset;
+  sigaddset(&signal_set, SIGLOWVOLTAGE);
+  sigaddset(&signal_set, SIGWAKEUP);
+  sigaddset(&signal_set, SIGIGNOFF);
+
+  // Set signals mask to be blocked by thread
+  return !pthread_sigmask(SIG_BLOCK, &signal_set, nullptr);
+}
+
+void Signals::SendSignal(const int signo, const pid_t pid) {
+  if (kill(pid, signo) == -1) {
+    std::cerr << "Error sending signal: " << strsignal(signo) << " to " << pid
+              << " .Error: " << strerror(errno) << std::endl;
+  }
+}
+
+pid_t Signals::Fork() {
+  return fork();
+}
+
+void Signals::ExitProcess(const int status) {
+  exit(status);
+}
+
+void Signals::WaitPid(pid_t cpid, int* status, int options) {
+  waitpid(cpid, status, options);
+}
+
 namespace {
 bool CatchSIGSEGV(sighandler_t handler) {
   struct sigaction act;
@@ -63,7 +102,7 @@ bool CatchSIGSEGV(sighandler_t handler) {
 }
 }  // namespace
 
-bool utils::WaitTerminationSignals(sighandler_t sig_handler) {
+bool Signals::WaitTerminationSignals(sighandler_t sig_handler) {
   sigset_t signal_set;
   int sig = -1;
 
@@ -81,3 +120,4 @@ bool utils::WaitTerminationSignals(sighandler_t sig_handler) {
   }
   return false;
 }
+}  // namespace utils
diff --git a/src/components/utils/test/include/utils/mock_signals_posix.h b/src/components/utils/test/include/utils/mock_signals_posix.h
new file mode 100644
index 0000000000..1aad2d5873
--- /dev/null
+++ b/src/components/utils/test/include/utils/mock_signals_posix.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2018, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef SRC_COMPONENTS_UTILS_TEST_INCLUDE_UTILS_MOCK_SIGNALS_POSIX_H_
+#define SRC_COMPONENTS_UTILS_TEST_INCLUDE_UTILS_MOCK_SIGNALS_POSIX_H_
+
+#include "gmock/gmock.h"
+#include "utils/signals.h"
+#include <signal.h>
+#include "appMain/low_voltage_signals_handler.h"
+
+namespace utils {
+
+class MockSignalsPosix {
+ public:
+  MOCK_METHOD0(UnsubscribeFromTermination, bool());
+  MOCK_METHOD1(WaitTerminationSignals, bool(sighandler_t sig_handler));
+  MOCK_METHOD1(
+      UnsubscribeFromLowVoltageSignals,
+      bool(const main_namespace::LowVoltageSignalsOffset& offset_data));
+  MOCK_METHOD2(SendSignal, void(const int signo, const pid_t pid));
+  MOCK_METHOD0(Fork, pid_t());
+  MOCK_METHOD1(ExitProcess, void(const int status));
+  MOCK_METHOD3(WaitPid, void(pid_t cpid, int* status, int options));
+
+  static MockSignalsPosix* signals_posix_mock();
+};
+
+}  // namespace utils
+#endif  // SRC_COMPONENTS_UTILS_TEST_INCLUDE_UTILS_MOCK_SIGNALS_POSIX_H_
diff --git a/src/components/utils/test/mock_signals_posix.cc b/src/components/utils/test/mock_signals_posix.cc
new file mode 100644
index 0000000000..47531b4a9f
--- /dev/null
+++ b/src/components/utils/test/mock_signals_posix.cc
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2018, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "gtest/gtest.h"
+#include "gmock/gmock.h"
+#include "utils/mock_signals_posix.h"
+#include "utils/signals.h"
+
+namespace utils {
+
+bool Signals::UnsubscribeFromTermination() {
+  return MockSignalsPosix::signals_posix_mock()->UnsubscribeFromTermination();
+}
+
+bool Signals::WaitTerminationSignals(sighandler_t sig_handler) {
+  return MockSignalsPosix::signals_posix_mock()->WaitTerminationSignals(
+      sig_handler);
+}
+
+bool Signals::UnsubscribeFromLowVoltageSignals(
+    const main_namespace::LowVoltageSignalsOffset& offset_data) {
+  return MockSignalsPosix::signals_posix_mock()
+      ->UnsubscribeFromLowVoltageSignals(offset_data);
+}
+
+void Signals::SendSignal(const int signo, const pid_t pid) {
+  MockSignalsPosix::signals_posix_mock()->SendSignal(signo, pid);
+}
+
+void Signals::ExitProcess(const int status) {
+  MockSignalsPosix::signals_posix_mock()->ExitProcess(status);
+}
+
+void Signals::WaitPid(pid_t cpid, int* status, int options) {
+  MockSignalsPosix::signals_posix_mock()->WaitPid(cpid, status, options);
+}
+
+pid_t Signals::Fork() {
+  return MockSignalsPosix::signals_posix_mock()->Fork();
+}
+
+MockSignalsPosix* MockSignalsPosix::signals_posix_mock() {
+  static ::testing::NiceMock<MockSignalsPosix> signals_posix_mock;
+  return &signals_posix_mock;
+}
+
+}  // namespace utils