feat: add autoware_version_manager package

autoware_version_manager/CMakeLists.txt

@@ -0,0 +1,28 @@
+cmake_minimum_required(VERSION 3.14)
+project(autoware_version_manager)
+
+find_package(autoware_cmake REQUIRED)
+autoware_package()
+
+set(NODE_NAME ${PROJECT_NAME}_node)
+set(EXEC_NAME ${PROJECT_NAME}_exe)
+
+ament_auto_add_library(autoware_version_reader SHARED
+  src/autoware_version_reader.cpp)
+
+ament_auto_add_library(${NODE_NAME}
+  src/include/autoware_version_manager_core.hpp
+  src/include/parse_version.hpp
+  src/autoware_version_manager_core.cpp
+  src/parse_version.cpp)
+
+target_link_libraries(${NODE_NAME}
+  autoware_version_reader)
+
+rclcpp_components_register_node(${NODE_NAME}
+  PLUGIN "autoware_version_manager::AutowareVersionManagerNode"
+  EXECUTABLE ${EXEC_NAME})
+
+ament_auto_package(INSTALL_TO_SHARE
+  launch
+  data)

autoware_version_manager/README.md

@@ -0,0 +1,7 @@
+# autoware_version_manager
+
+```bash
+ros2 service call /get_version_autoware autoware_system_msgs/srv/GetVersionAutoware
+
+ros2 service call /get_version_component_interface autoware_system_msgs/srv/GetVersionComponentInterface
+```

autoware_version_manager/data/version-autoware.yaml

@@ -0,0 +1,5 @@
+# Autoware version (CalVer with YYYY.0M.MICRO)
+
+year: 2023
+month: 7
+micro: 0

autoware_version_manager/data/version-component-interface.yaml

@@ -0,0 +1,5 @@
+# Autoware component interface version (SemVer)
+
+major: 1
+minor: 0
+patch: 0

autoware_version_manager/include/autoware_version_manager/autoware_version_reader.hpp

@@ -0,0 +1,43 @@
+// Copyright 2023 The Autoware Foundation
+//
+// 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 AUTOWARE_VERSION_MANAGER__AUTOWARE_VERSION_READER_HPP_
+#define AUTOWARE_VERSION_MANAGER__AUTOWARE_VERSION_READER_HPP_
+
+#include "autoware_version_manager/version_types.hpp"
+
+#include <rclcpp/rclcpp.hpp>
+
+#include <optional>
+
+namespace autoware_version_manager
+{
+class AutowareVersionReaderNode : public rclcpp::Node
+{
+public:
+  explicit AutowareVersionReaderNode(const rclcpp::NodeOptions & node_options);
+
+  const VersionAutoware & get_version_autoware() const;
+  const VersionInterface & get_version_component_interface() const;
+
+private:
+  VersionAutoware version_autoware_;
+  VersionInterface version_component_interface_;
+};
+
+std::optional<VersionAutoware> get_version_autoware_directly();
+
+}  // namespace autoware_version_manager
+
+#endif  // AUTOWARE_VERSION_MANAGER__AUTOWARE_VERSION_READER_HPP_

autoware_version_manager/include/autoware_version_manager/version_types.hpp

@@ -0,0 +1,44 @@
+// Copyright 2023 The Autoware Foundation
+//
+// 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 AUTOWARE_VERSION_MANAGER__VERSION_TYPES_HPP_
+#define AUTOWARE_VERSION_MANAGER__VERSION_TYPES_HPP_
+
+#include <cstdint>
+
+namespace autoware_version_manager
+{
+// Autoware version (CalVer with YYYY.0M.MICRO)
+// https://calver.org/#scheme
+struct VersionAutoware
+{
+  using uint16_t = std::uint16_t;
+  uint16_t year;   // year of release
+  uint16_t month;  // month of release
+  uint16_t micro;  // increments for bug fixes or patches
+};
+
+// Autoware component interface version (SemVer)
+// https://semver.org/
+struct VersionInterface
+{
+  using uint16_t = std::uint16_t;
+  uint16_t major;  // increments for breaking changes
+  uint16_t minor;  // increments for non-breaking changes
+  uint16_t patch;  // increments for bug fixes or patches
+};
+
+}  // namespace autoware_version_manager
+
+#endif  // AUTOWARE_VERSION_MANAGER__VERSION_TYPES_HPP_

autoware_version_manager/launch/autoware_version_manager.launch.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0"?>
+<launch>
+  <node pkg="autoware_version_manager" exec="autoware_version_manager_exe" name="autoware_version_manager" output="screen"/>
+</launch>

autoware_version_manager/package.xml

@@ -0,0 +1,30 @@
+<?xml version="1.0"?>
+<package format="2">
+  <name>autoware_version_manager</name>
+  <version>0.0.0</version>
+  <description>The autoware_version_manager package</description>
+
+  <maintainer email="mfc@leodrive.ai">M. Fatih Cırıt</maintainer>
+  <maintainer email="isamu.takagi@tier4.jp">Takagi, Isamu</maintainer>
+
+  <license>Apache License 2.0</license>
+
+  <author email="mfc@leodrive.ai">M. Fatih Cırıt</author>
+
+  <buildtool_depend>ament_cmake_auto</buildtool_depend>
+  <buildtool_depend>autoware_cmake</buildtool_depend>
+
+  <depend>ament_index_cpp</depend>
+  <depend>autoware_system_msgs</depend>
+  <depend>rclcpp</depend>
+  <depend>rclcpp_components</depend>
+  <depend>yaml_cpp_vendor</depend>
+
+  <test_depend>ament_cmake_ros</test_depend>
+  <test_depend>ament_lint_auto</test_depend>
+  <test_depend>autoware_lint_common</test_depend>
+
+  <export>
+    <build_type>ament_cmake</build_type>
+  </export>
+</package>

autoware_version_manager/src/autoware_version_manager_core.cpp

@@ -0,0 +1,89 @@
+// Copyright 2023 The Autoware Foundation
+//
+// 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.
+
+#include "include/autoware_version_manager_core.hpp"
+
+#include "autoware_version_manager/autoware_version_reader.hpp"
+#include "include/parse_version.hpp"
+
+#include <ament_index_cpp/get_package_share_directory.hpp>
+#include <rclcpp/rclcpp.hpp>
+
+namespace autoware_version_manager
+{
+
+AutowareVersionManagerNode::AutowareVersionManagerNode(const rclcpp::NodeOptions & node_options)
+: rclcpp::Node("autoware_version_manager_node", node_options)
+{
+  AutowareVersionReaderNode autoware_version_reader_node(rclcpp::NodeOptions{});
+
+  if (auto version_autoware = get_version_autoware_directly()) {
+    version_autoware_ = version_autoware.value();
+  } else {
+    RCLCPP_ERROR(get_logger(), "Couldn't get the Autoware version");
+    exit(EXIT_FAILURE);
+  }
+
+  version_component_interface_ = autoware_version_reader_node.get_version_component_interface();
+
+  srv_get_version_autoware_ = create_service<autoware_system_msgs::srv::GetVersionAutoware>(
+    "get_version_autoware", std::bind(
+                              &AutowareVersionManagerNode::on_get_version_autoware, this,
+                              std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
+
+  srv_get_version_component_interface_ =
+    create_service<autoware_system_msgs::srv::GetVersionComponentInterface>(
+      "get_version_component_interface",
+      std::bind(
+        &AutowareVersionManagerNode::on_get_version_component_interface, this,
+        std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
+
+  RCLCPP_INFO(
+    get_logger(), "Autoware version: %d.%02d.%d", version_autoware_.year, version_autoware_.month,
+    version_autoware_.micro);
+
+  RCLCPP_INFO(
+    get_logger(), "Component interface version: %d.%d.%d", version_component_interface_.major,
+    version_component_interface_.minor, version_component_interface_.patch);
+}
+
+void AutowareVersionManagerNode::on_get_version_autoware(
+  const std::shared_ptr<rmw_request_id_t> & request_header,
+  const std::shared_ptr<autoware_system_msgs::srv::GetVersionAutoware::Request> & request,
+  const std::shared_ptr<autoware_system_msgs::srv::GetVersionAutoware::Response> & response) const
+{
+  (void)request_header;
+  (void)request;
+  response->month = version_autoware_.month;
+  response->year = version_autoware_.year;
+  response->micro = version_autoware_.micro;
+}
+
+void AutowareVersionManagerNode::on_get_version_component_interface(
+  const std::shared_ptr<rmw_request_id_t> & request_header,
+  const std::shared_ptr<autoware_system_msgs::srv::GetVersionComponentInterface::Request> & request,
+  const std::shared_ptr<autoware_system_msgs::srv::GetVersionComponentInterface::Response> &
+    response) const
+{
+  (void)request_header;
+  (void)request;
+  response->major = version_component_interface_.major;
+  response->minor = version_component_interface_.minor;
+  response->patch = version_component_interface_.patch;
+}
+
+}  // namespace autoware_version_manager
+
+#include <rclcpp_components/register_node_macro.hpp>
+RCLCPP_COMPONENTS_REGISTER_NODE(autoware_version_manager::AutowareVersionManagerNode)

autoware_version_manager/src/autoware_version_reader.cpp

@@ -0,0 +1,78 @@
+// Copyright 2023 The Autoware Foundation
+//
+// 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.
+
+#include "autoware_version_manager/autoware_version_reader.hpp"
+
+#include "include/parse_version.hpp"
+
+#include <ament_index_cpp/get_package_share_directory.hpp>
+#include <rclcpp/rclcpp.hpp>
+
+namespace autoware_version_manager
+{
+
+AutowareVersionReaderNode::AutowareVersionReaderNode(const rclcpp::NodeOptions & node_options)
+: rclcpp::Node("autoware_version_reader_node", node_options)
+{
+  try {
+    const std::filesystem::path path_version_autoware =
+      ament_index_cpp::get_package_share_directory("autoware_version_manager") +
+      "/data/version-autoware.yaml";
+    const std::filesystem::path path_version_component_interface =
+      ament_index_cpp::get_package_share_directory("autoware_version_manager") +
+      "/data/version-component-interface.yaml";
+
+    version_autoware_ = parse_version::parse_autoware_version(path_version_autoware);
+    version_component_interface_ =
+      parse_version::parse_interface_version(path_version_component_interface);
+  } catch (const std::exception & e) {
+    RCLCPP_ERROR(get_logger(), "Exception: %s", e.what());
+    exit(EXIT_FAILURE);
+  }
+
+  RCLCPP_INFO(
+    get_logger(), "Autoware version: %d.%02d.%d", version_autoware_.year, version_autoware_.month,
+    version_autoware_.micro);
+
+  RCLCPP_INFO(
+    get_logger(), "Component interface version: %d.%d.%d", version_component_interface_.major,
+    version_component_interface_.minor, version_component_interface_.patch);
+}
+
+const VersionAutoware & AutowareVersionReaderNode::get_version_autoware() const
+{
+  return version_autoware_;
+}
+
+const VersionInterface & AutowareVersionReaderNode::get_version_component_interface() const
+{
+  return version_component_interface_;
+}
+
+std::optional<VersionAutoware> get_version_autoware_directly()
+{
+  try {
+    const std::filesystem::path path_version_autoware =
+      ament_index_cpp::get_package_share_directory("autoware_version_manager") +
+      "/data/version-autoware.yamla";
+
+    auto version_autoware = parse_version::parse_autoware_version(path_version_autoware);
+
+    return version_autoware;
+  } catch (const std::exception & e) {
+    RCLCPP_ERROR(rclcpp::get_logger("get_version_autoware"), "Exception: %s", e.what());
+    return std::nullopt;
+  }
+}
+}  // namespace autoware_version_manager