Delete Log

Delete a secific log.

• Service Name: log_manager/delete_log

• Service Type: clearpath_logger_msgs/srv/DeleteLog

Python

from clearpath_config.common.utils.yaml import read_yaml
import rclpy
from rclpy.node import Node
from clearpath_logger_msgs.srv import DeleteLog

ROBOT_CONFIG_PATH = '/etc/clearpath/robot.yaml'
LOGGING_NAME = 'DeleteLog'

LOG_ID: str = ''

class Logger(Node):

    def __init__(self, namespace: str):
        super().__init__('delete_log_client')
        self._start_logger_client = self.create_client(DeleteLog, f'/{namespace}/log_manager/delete_log')

        while not self._start_logger_client.wait_for_service(timeout_sec=2.0):
            self.get_logger().info(f'[{LOGGING_NAME}] /{namespace}/log_manager/delete_log service not available, waiting again...')

    def delete_log(self):
        req = DeleteLog.Request()
        req.uuid = LOG_ID
        req.delete_media = False
        req.purge_record = False
        self.future = self._start_logger_client.call_async(req)
        self.future.add_done_callback(self.delete_log_srv_response_cb)

    def delete_log_srv_response_cb(self, future):
        try:
            response = future.result()
            if response.success:
                self.get_logger().info(f'[{LOGGING_NAME}] Deleted log successfully!')
            else:
                self.get_logger().error(f'[{LOGGING_NAME}] Failed to delete log')
        except Exception as e:
            self.get_logger().error(f'[{LOGGING_NAME}] Service call failed: {e}')

        self.destroy_node()
        rclpy.shutdown()


def main(args=None):
    rclpy.init(args=args)
    robot_config = read_yaml(ROBOT_CONFIG_PATH)
    namespace = robot_config['system']['ros2']['namespace']

    logger = Logger(namespace)
    logger.delete_log()

    rclpy.spin(logger)


if __name__ == '__main__':
    main()

C++

#include "rclcpp/rclcpp.hpp"
#include "clearpath_logger_msgs/srv/delete_log.hpp"

#include <chrono>
#include <cstdlib>
#include <memory>
#include <yaml-cpp/yaml.h>

using namespace std::chrono_literals;

int main(int argc, char **argv)
{
  rclcpp::init(argc, argv);
  
  YAML::Node robot_config = YAML::LoadFile("/etc/clearpath/robot.yaml");
  std::string namespace_ = robot_config["system"]["ros2"]["namespace"].as<std::string>();

  std::shared_ptr<rclcpp::Node> node = rclcpp::Node::make_shared("delete_log_client");
  rclcpp::Client<clearpath_logger_msgs::srv::DeleteLog>::SharedPtr client =
    node->create_client<clearpath_logger_msgs::srv::DeleteLog>("/" + namespace_ + "/" + std::string("log_manager/delete_log"));

  auto request = std::make_shared<clearpath_logger_msgs::srv::DeleteLog::Request>();
  request->uuid = "";
  request->delete_media = False;
  request->purge_record = False;

while (!client->wait_for_service(2s)) {
    if (!rclcpp::ok()) {
      RCLCPP_ERROR(rclcpp::get_logger("delete_log_client"), "Interrupted while waiting for the service. Exiting.");
      return 0;
    }
    RCLCPP_INFO(rclcpp::get_logger("delete_log_client"), "/%s/log_manager/delete_log service not available, waiting again...", namespace_.c_str());
  }

  auto result = client->async_send_request(request);

  // Wait for the result.
  if (rclcpp::spin_until_future_complete(node, result) ==
    rclcpp::FutureReturnCode::SUCCESS)
  {
    if (result.get()->success)
    {
      RCLCPP_INFO(rclcpp::get_logger("delete_log_client"), "Deleted log successfully!");
    }
    else
    {
      RCLCPP_ERROR(rclcpp::get_logger("delete_log_client"), "Failed to delete log!");
    }
  } else {
    RCLCPP_ERROR(rclcpp::get_logger("delete_log_client"), "Failed to call service /%s/log_manager/delete_log", namespace_.c_str());
  }

  rclcpp::shutdown();
  return 0;
}