Update ci (#239)

urfeex · web-flow · commit 6d4918717295 · 2024-12-18T08:11:22.000+01:00
This is a cleanup of our current CI jobs. Particularly, this chages:

- Push event triggers only for master branch
- Updated clang-format
- Removed iron workflow
- Improved running ICI in ACT
- Enabled clang-tidy in ICI
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -1,5 +1,10 @@
 name: Integration tests
-on: [push, pull_request]
+on:
+  workflow_dispatch:
+  pull_request:
+  push:
+    branches:
+      - main
 
 jobs:
   build:
diff --git a/.github/workflows/industrial-ci.yml b/.github/workflows/industrial-ci.yml
@@ -1,5 +1,10 @@
 name: ROS industrial ci
-on: [push, pull_request]
+on:
+  workflow_dispatch:
+  pull_request:
+  push:
+    branches:
+      - master
 
 jobs:
   industrial_ci:
@@ -11,7 +16,6 @@ jobs:
         ROS_DISTRO:
           - {NAME: noetic, DOWNSTREAM_WORKSPACE: "github:UniversalRobots/Universal_Robots_ROS_Driver#master https://raw.githubusercontent.com/UniversalRobots/Universal_Robots_ROS_Driver/master/.noetic.rosinstall"}
           - {NAME: humble, DOWNSTREAM_WORKSPACE: "github:UniversalRobots/Universal_Robots_ROS2_Driver#humble"}
-          - {NAME: iron, DOWNSTREAM_WORKSPACE: "github:UniversalRobots/Universal_Robots_ROS2_Driver#iron"}
           - {NAME: jazzy, DOWNSTREAM_WORKSPACE: "github:UniversalRobots/Universal_Robots_ROS2_Driver#main"}
           - {NAME: rolling, DOWNSTREAM_WORKSPACE: "github:UniversalRobots/Universal_Robots_ROS2_Driver#main"}
         ROS_REPO:
@@ -22,6 +26,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - run: docker network create --subnet=192.168.56.0/24 ursim_net
+        if: ${{ !env.ACT }}
       - uses: 'ros-industrial/industrial_ci@master'
         env:
           IMMEDIATE_TEST_OUTPUT: true
@@ -30,3 +35,4 @@ jobs:
           DOWNSTREAM_WORKSPACE: ${{matrix.ROS_DISTRO.DOWNSTREAM_WORKSPACE}}
           ROS_DISTRO: ${{matrix.ROS_DISTRO.NAME}}
           ROS_REPO: ${{matrix.ROS_REPO}}
+          CLANG_TIDY: true
diff --git a/.github/workflows/pre-commit.yml b/.github/workflows/pre-commit.yml
@@ -8,7 +8,7 @@ on:
   pull_request:
   push:
     branches:
-      - main
+      - master
 
 jobs:
   pre-commit:
@@ -19,8 +19,6 @@ jobs:
     - uses: actions/setup-python@v5
       with:
         python-version: 3.10.4
-    - name: Install system hooks
-      run: sudo apt-get install clang-format-14 cppcheck
     - uses: pre-commit/action@v3.0.1
       with:
         extra_args: --all-files --hook-stage manual
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/pre-commit/mirrors-clang-format
-    rev: 'v14.0.6'
+    rev: 'v19.1.5'
     hooks:
       - id: clang-format
   - repo: https://github.com/DavidAnson/markdownlint-cli2
diff --git a/examples/force_mode_example.cpp b/examples/force_mode_example.cpp
@@ -55,8 +55,8 @@ const std::string CALIBRATION_CHECKSUM = "calib_12788084448423163542";
 std::unique_ptr<UrDriver> g_my_driver;
 std::unique_ptr<DashboardClient> g_my_dashboard;
 
-std::condition_variable g_program_running_cv_;
-std::mutex g_program_running_mutex_;
+std::condition_variable g_program_running_cv;
+std::mutex g_program_running_mutex;
 bool g_program_running;
 
 // We need a callback function to register. See UrDriver's parameters for details.
@@ -66,9 +66,9 @@ void handleRobotProgramState(bool program_running)
   std::cout << "\033[1;32mProgram running: " << std::boolalpha << program_running << "\033[0m\n" << std::endl;
   if (program_running)
   {
-    std::lock_guard<std::mutex> lk(g_program_running_mutex_);
+    std::lock_guard<std::mutex> lk(g_program_running_mutex);
     g_program_running = program_running;
-    g_program_running_cv_.notify_one();
+    g_program_running_cv.notify_one();
   }
 }
 
@@ -84,8 +84,8 @@ void sendFreedriveMessageOrDie(const control::FreedriveControlMessage freedrive_
 
 bool waitForProgramRunning(int milliseconds = 100)
 {
-  std::unique_lock<std::mutex> lk(g_program_running_mutex_);
-  if (g_program_running_cv_.wait_for(lk, std::chrono::milliseconds(milliseconds)) == std::cv_status::no_timeout ||
+  std::unique_lock<std::mutex> lk(g_program_running_mutex);
+  if (g_program_running_cv.wait_for(lk, std::chrono::milliseconds(milliseconds)) == std::cv_status::no_timeout ||
       g_program_running == true)
   {
     return true;
@@ -149,8 +149,8 @@ int main(int argc, char* argv[])
 
   // Now the robot is ready to receive a program
   std::unique_ptr<ToolCommSetup> tool_comm_setup;
-  const bool HEADLESS = true;
-  g_my_driver.reset(new UrDriver(robot_ip, SCRIPT_FILE, OUTPUT_RECIPE, INPUT_RECIPE, &handleRobotProgramState, HEADLESS,
+  const bool headless = true;
+  g_my_driver.reset(new UrDriver(robot_ip, SCRIPT_FILE, OUTPUT_RECIPE, INPUT_RECIPE, &handleRobotProgramState, headless,
                                  std::move(tool_comm_setup)));
 
   if (!g_my_driver->checkCalibration(CALIBRATION_CHECKSUM))
diff --git a/examples/freedrive_example.cpp b/examples/freedrive_example.cpp
@@ -128,8 +128,8 @@ int main(int argc, char* argv[])
 
   // Now the robot is ready to receive a program
   std::unique_ptr<ToolCommSetup> tool_comm_setup;
-  const bool HEADLESS = true;
-  g_my_driver.reset(new UrDriver(robot_ip, SCRIPT_FILE, OUTPUT_RECIPE, INPUT_RECIPE, &handleRobotProgramState, HEADLESS,
+  const bool headless = true;
+  g_my_driver.reset(new UrDriver(robot_ip, SCRIPT_FILE, OUTPUT_RECIPE, INPUT_RECIPE, &handleRobotProgramState, headless,
                                  std::move(tool_comm_setup), CALIBRATION_CHECKSUM));
 
   // Once RTDE communication is started, we have to make sure to read from the interface buffer, as
diff --git a/examples/full_driver.cpp b/examples/full_driver.cpp
@@ -107,8 +107,8 @@ int main(int argc, char* argv[])
   // Now the robot is ready to receive a program
 
   std::unique_ptr<ToolCommSetup> tool_comm_setup;
-  const bool HEADLESS = true;
-  g_my_driver.reset(new UrDriver(robot_ip, SCRIPT_FILE, OUTPUT_RECIPE, INPUT_RECIPE, &handleRobotProgramState, HEADLESS,
+  const bool headless = true;
+  g_my_driver.reset(new UrDriver(robot_ip, SCRIPT_FILE, OUTPUT_RECIPE, INPUT_RECIPE, &handleRobotProgramState, headless,
                                  std::move(tool_comm_setup), CALIBRATION_CHECKSUM));
 
   // Once RTDE communication is started, we have to make sure to read from the interface buffer, as
diff --git a/examples/primary_pipeline_calibration.cpp b/examples/primary_pipeline_calibration.cpp
@@ -26,7 +26,7 @@ using namespace urcl;
 class CalibrationConsumer : public urcl::comm::IConsumer<urcl::primary_interface::PrimaryPackage>
 {
 public:
-  CalibrationConsumer() : calibrated_(0), have_received_data(false)
+  CalibrationConsumer() : calibrated_(0), have_received_data_(false)
   {
   }
   virtual ~CalibrationConsumer() = default;
@@ -38,25 +38,25 @@ class CalibrationConsumer : public urcl::comm::IConsumer<urcl::primary_interface
     {
       URCL_LOG_INFO("%s", product->toString().c_str());
       calibrated_ = kin_info->calibration_status_;
-      have_received_data = true;
+      have_received_data_ = true;
     }
     return true;
   }
 
   bool isCalibrated() const
   {
-    const uint32_t LINEARIZED = 2;
-    return calibrated_ == LINEARIZED;
+    const uint32_t linearized = 2;
+    return calibrated_ == linearized;
   }
 
   bool calibrationStatusReceived()
   {
-    return have_received_data;
+    return have_received_data_;
   }
 
 private:
   uint32_t calibrated_;
-  bool have_received_data;
+  bool have_received_data_;
 };
 
 // In a real-world example it would be better to get those values from command line parameters / a better configuration
diff --git a/examples/rtde_client.cpp b/examples/rtde_client.cpp
@@ -70,8 +70,8 @@ int main(int argc, char* argv[])
   // loop.
   my_client.start();
 
-  unsigned long startTime = clock();
-  while (second_to_run < 0 || ((clock() - startTime) / CLOCKS_PER_SEC) < static_cast<unsigned int>(second_to_run))
+  unsigned long start_time = clock();
+  while (second_to_run < 0 || ((clock() - start_time) / CLOCKS_PER_SEC) < static_cast<unsigned int>(second_to_run))
   {
     // Read latest RTDE package. This will block for READ_TIMEOUT, so the
     // robot will effectively be in charge of setting the frequency of this loop unless RTDE
@@ -93,9 +93,7 @@ int main(int argc, char* argv[])
     {
       // This will happen for example, when the required keys are not configured inside the input
       // recipe.
-      std::cout << "\033[1;31mSending RTDE data failed."
-                << "\033[0m\n"
-                << std::endl;
+      std::cout << "\033[1;31mSending RTDE data failed." << "\033[0m\n" << std::endl;
       return 1;
     }
 
diff --git a/examples/spline_example.cpp b/examples/spline_example.cpp
@@ -52,7 +52,7 @@ std::unique_ptr<UrDriver> g_my_driver;
 std::unique_ptr<DashboardClient> g_my_dashboard;
 vector6d_t g_joint_positions;
 
-void SendTrajectory(const std::vector<vector6d_t>& p_p, const std::vector<vector6d_t>& p_v,
+void sendTrajectory(const std::vector<vector6d_t>& p_p, const std::vector<vector6d_t>& p_v,
                     const std::vector<vector6d_t>& p_a, const std::vector<double>& time, bool use_spline_interpolation_)
 {
   assert(p_p.size() == time.size());
@@ -146,8 +146,8 @@ int main(int argc, char* argv[])
   }
 
   // if the robot is not powered on and ready
-  std::string robotModeRunning("RUNNING");
-  while (!g_my_dashboard->commandRobotMode(robotModeRunning))
+  std::string robot_mode_running("RUNNING");
+  while (!g_my_dashboard->commandRobotMode(robot_mode_running))
   {
     // Power it off
     if (!g_my_dashboard->commandPowerOff())
@@ -174,8 +174,8 @@ int main(int argc, char* argv[])
   // Now the robot is ready to receive a program
 
   std::unique_ptr<ToolCommSetup> tool_comm_setup;
-  const bool HEADLESS = true;
-  g_my_driver.reset(new UrDriver(robot_ip, SCRIPT_FILE, OUTPUT_RECIPE, INPUT_RECIPE, &handleRobotProgramState, HEADLESS,
+  const bool headless = true;
+  g_my_driver.reset(new UrDriver(robot_ip, SCRIPT_FILE, OUTPUT_RECIPE, INPUT_RECIPE, &handleRobotProgramState, headless,
                                  std::move(tool_comm_setup), CALIBRATION_CHECKSUM));
 
   g_my_driver->registerTrajectoryDoneCallback(&handleTrajectoryState);
@@ -241,7 +241,7 @@ int main(int argc, char* argv[])
   }
 
   // CUBIC
-  SendTrajectory(p, v, std::vector<vector6d_t>(), time, true);
+  sendTrajectory(p, v, std::vector<vector6d_t>(), time, true);
 
   g_trajectory_running = true;
   while (g_trajectory_running)
@@ -272,7 +272,7 @@ int main(int argc, char* argv[])
   URCL_LOG_INFO("CUBIC Movement done");
 
   // QUINTIC
-  SendTrajectory(p, v, a, time, true);
+  sendTrajectory(p, v, a, time, true);
 
   g_trajectory_running = true;
   while (g_trajectory_running)
diff --git a/examples/tool_contact_example.cpp b/examples/tool_contact_example.cpp
@@ -124,8 +124,8 @@ int main(int argc, char* argv[])
 
   // Now the robot is ready to receive a program
   std::unique_ptr<ToolCommSetup> tool_comm_setup;
-  const bool HEADLESS = true;
-  g_my_driver.reset(new UrDriver(robot_ip, SCRIPT_FILE, OUTPUT_RECIPE, INPUT_RECIPE, &handleRobotProgramState, HEADLESS,
+  const bool headless = true;
+  g_my_driver.reset(new UrDriver(robot_ip, SCRIPT_FILE, OUTPUT_RECIPE, INPUT_RECIPE, &handleRobotProgramState, headless,
                                  std::move(tool_comm_setup), CALIBRATION_CHECKSUM));
 
   g_my_driver->registerToolContactResultCallback(&handleToolContactResult);
diff --git a/src/ur/ur_driver.cpp b/src/ur/ur_driver.cpp
@@ -136,9 +136,7 @@ urcl::UrDriver::UrDriver(const std::string& robot_ip, const std::string& script_
     }
     begin_replace << "set_tool_voltage("
                   << static_cast<std::underlying_type<ToolVoltage>::type>(tool_comm_setup->getToolVoltage()) << ")\n";
-    begin_replace << "set_tool_communication("
-                  << "True"
-                  << ", " << tool_comm_setup->getBaudRate() << ", "
+    begin_replace << "set_tool_communication(" << "True" << ", " << tool_comm_setup->getBaudRate() << ", "
                   << static_cast<std::underlying_type<Parity>::type>(tool_comm_setup->getParity()) << ", "
                   << tool_comm_setup->getStopBits() << ", " << tool_comm_setup->getRxIdleChars() << ", "
                   << tool_comm_setup->getTxIdleChars() << ")";
diff --git a/tests/test_dashboard_client.cpp b/tests/test_dashboard_client.cpp
@@ -39,14 +39,14 @@
 
 using namespace urcl;
 
-std::string ROBOT_IP = "192.168.56.101";
+std::string g_ROBOT_IP = "192.168.56.101";
 
 class DashboardClientTest : public ::testing::Test
 {
 protected:
   void SetUp()
   {
-    dashboard_client_.reset(new DashboardClient(ROBOT_IP));
+    dashboard_client_.reset(new DashboardClient(g_ROBOT_IP));
   }
 
   void TearDown()
@@ -227,7 +227,7 @@ int main(int argc, char* argv[])
   {
     if (std::string(argv[i]) == "--robot_ip" && i + 1 < argc)
     {
-      ROBOT_IP = argv[i + 1];
+      g_ROBOT_IP = argv[i + 1];
       break;
     }
   }
diff --git a/tests/test_pipeline.cpp b/tests/test_pipeline.cpp
@@ -60,7 +60,7 @@ class PipelineTest : public ::testing::Test
     pipeline_->init();
   }
 
-  void Teardown()
+  void teardown()
   {
     // Clean up
     pipeline_->stop();
diff --git a/tests/test_producer.cpp b/tests/test_producer.cpp
@@ -49,7 +49,7 @@ class ProducerTest : public ::testing::Test
     server_->start();
   }
 
-  void Teardown()
+  void teardown()
   {
     // Clean up
     server_.reset();
diff --git a/tests/test_robot_receive_timeout.cpp b/tests/test_robot_receive_timeout.cpp
diff --git a/tests/test_rtde_client.cpp b/tests/test_rtde_client.cpp
diff --git a/tests/test_spline_interpolation.cpp b/tests/test_spline_interpolation.cpp
diff --git a/tests/test_stream.cpp b/tests/test_stream.cpp
diff --git a/tests/test_ur_driver.cpp b/tests/test_ur_driver.cpp

Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ using namespace urcl;`
`26`	`26`	`class CalibrationConsumer : public urcl::comm::IConsumer<urcl::primary_interface::PrimaryPackage>`
`27`	`27`	`{`
`28`	`28`	`public:`
`29`		`- CalibrationConsumer() : calibrated_(0), have_received_data(false)`
	`29`	`+ CalibrationConsumer() : calibrated_(0), have_received_data_(false)`
`30`	`30`	`{`
`31`	`31`	`}`
`32`	`32`	`virtual ~CalibrationConsumer() = default;`
`@@ -38,25 +38,25 @@ class CalibrationConsumer : public urcl::comm::IConsumer<urcl::primary_interface`
`38`	`38`	`{`
`39`	`39`	`URCL_LOG_INFO("%s", product->toString().c_str());`
`40`	`40`	`calibrated_ = kin_info->calibration_status_;`
`41`		`- have_received_data = true;`
	`41`	`+ have_received_data_ = true;`
`42`	`42`	`}`
`43`	`43`	`return true;`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`bool isCalibrated() const`
`47`	`47`	`{`
`48`		`- const uint32_t LINEARIZED = 2;`
`49`		`- return calibrated_ == LINEARIZED;`
	`48`	`+ const uint32_t linearized = 2;`
	`49`	`+ return calibrated_ == linearized;`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`bool calibrationStatusReceived()`
`53`	`53`	`{`
`54`		`- return have_received_data;`
	`54`	`+ return have_received_data_;`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`private:`
`58`	`58`	`uint32_t calibrated_;`
`59`		`- bool have_received_data;`
	`59`	`+ bool have_received_data_;`
`60`	`60`	`};`
`61`	`61`
`62`	`62`	`// In a real-world example it would be better to get those values from command line parameters / a better configuration`
Original file line number	Diff line number	Diff line change
`@@ -70,8 +70,8 @@ int main(int argc, char* argv[])`
`70`	`70`	`// loop.`
`71`	`71`	`my_client.start();`
`72`	`72`
`73`		`- unsigned long startTime = clock();`
`74`		`- while (second_to_run < 0 \|\| ((clock() - startTime) / CLOCKS_PER_SEC) < static_cast<unsigned int>(second_to_run))`
	`73`	`+ unsigned long start_time = clock();`
	`74`	`+ while (second_to_run < 0 \|\| ((clock() - start_time) / CLOCKS_PER_SEC) < static_cast<unsigned int>(second_to_run))`
`75`	`75`	`{`
`76`	`76`	`// Read latest RTDE package. This will block for READ_TIMEOUT, so the`
`77`	`77`	`// robot will effectively be in charge of setting the frequency of this loop unless RTDE`
`@@ -93,9 +93,7 @@ int main(int argc, char* argv[])`
`93`	`93`	`{`
`94`	`94`	`// This will happen for example, when the required keys are not configured inside the input`
`95`	`95`	`// recipe.`
`96`		`- std::cout << "\033[1;31mSending RTDE data failed."`
`97`		`- << "\033[0m\n"`
`98`		`- << std::endl;`
	`96`	`+ std::cout << "\033[1;31mSending RTDE data failed." << "\033[0m\n" << std::endl;`
`99`	`97`	`return 1;`
`100`	`98`	`}`
`101`	`99`