GH-80 Write yaml file before shutdown

- Use interface to make writing optional in tests

rosbag2/CMakeLists.txt

@@ -26,7 +26,7 @@ find_package(rosidl_generator_cpp REQUIRED)
 add_library(${PROJECT_NAME} SHARED
   src/rosbag2/sequential_reader.cpp
   src/rosbag2/typesupport_helpers.cpp
-  src/rosbag2/writer.cpp)
+  src/rosbag2/writer_impl.cpp)
 
 ament_target_dependencies(${PROJECT_NAME}
   ament_index_cpp
@@ -71,6 +71,13 @@ if(BUILD_TESTING)
   if(TARGET rosbag2_typesupport_helpers_test)
     target_link_libraries(rosbag2_typesupport_helpers_test rosbag2)
   endif()
+
+  ament_add_gmock(test_writer
+    test/rosbag2/test_writer.cpp
+    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+  if(TARGET test_writer)
+    target_link_libraries(test_writer rosbag2)
+  endif()
 endif()
 
 ament_package()

rosbag2/include/rosbag2/writer.hpp

@@ -24,14 +24,6 @@
 #include "rosbag2/types.hpp"
 #include "rosbag2/visibility_control.hpp"
 
-// This is necessary because of using stl types here. It is completely safe, because
-// a) the member is not accessible from the outside
-// b) there are no inline functions.
-#ifdef _WIN32
-# pragma warning(push)
-# pragma warning(disable:4251)
-#endif
-
 namespace rosbag2
 {
 
@@ -42,15 +34,15 @@ namespace rosbag2
 class ROSBAG2_PUBLIC Writer
 {
 public:
-  virtual ~Writer();
+  virtual ~Writer() = default;
 
   /**
    * Opens a new bagfile and prepare it for writing messages. The bagfile must not exist.
    * This must be called before any other function is used.
    *
    * \param options Options to configure the storage
    */
-  virtual void open(const StorageOptions & options);
+  virtual void open(const StorageOptions & options) = 0;
 
   /**
    * Create a new topic in the underlying storage. Needs to be called for every topic used within
@@ -59,19 +51,15 @@ class ROSBAG2_PUBLIC Writer
    * \param topic_with_type name and type identifier of topic to be created
    * \throws runtime_error if the Writer is not open.
    */
-  virtual void create_topic(const TopicWithType & topic_with_type);
+  virtual void create_topic(const TopicWithType & topic_with_type) = 0;
 
   /**
    * Write a message to a bagfile. The topic needs to have been created before writing is possible.
    *
    * \param message to be written to the bagfile
    * \throws runtime_error if the Writer is not open.
    */
-  virtual void write(std::shared_ptr<SerializedBagMessage> message);
-
-private:
-  rosbag2_storage::StorageFactory factory_;
-  std::shared_ptr<rosbag2_storage::storage_interfaces::ReadWriteInterface> storage_;
+  virtual void write(std::shared_ptr<SerializedBagMessage> message) = 0;
 };
 
 }  // namespace rosbag2

rosbag2/include/rosbag2/writer_impl.hpp

@@ -0,0 +1,85 @@
+// Copyright 2018, Bosch Software Innovations GmbH.
+//
+// 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 ROSBAG2__WRITER_IMPL_HPP_
+#define ROSBAG2__WRITER_IMPL_HPP_
+
+#include <memory>
+#include <string>
+
+#include "rosbag2_storage/storage_factory.hpp"
+#include "rosbag2_storage/storage_interfaces/read_write_interface.hpp"
+#include "rosbag2/storage_options.hpp"
+#include "rosbag2/types.hpp"
+#include "rosbag2/visibility_control.hpp"
+#include "rosbag2/writer.hpp"
+
+// This is necessary because of using stl types here. It is completely safe, because
+// a) the member is not accessible from the outside
+// b) there are no inline functions.
+#ifdef _WIN32
+# pragma warning(push)
+# pragma warning(disable:4251)
+#endif
+
+namespace rosbag2
+{
+
+/**
+ * The Writer allows writing messages to a new bag. For every topic, information about its type
+ * needs to be added before writing the first message.
+ */
+class ROSBAG2_PUBLIC WriterImpl : public Writer
+{
+public:
+  ~WriterImpl() override;
+
+  /**
+   * Opens a new bagfile and prepare it for writing messages. The bagfile must not exist.
+   * This must be called before any other function is used.
+   *
+   * \param options Options to configure the storage
+   */
+  void open(const StorageOptions & options) override;
+
+  /**
+   * Create a new topic in the underlying storage. Needs to be called for every topic used within
+   * a message which is passed to write(...).
+   *
+   * \param topic_with_type name and type identifier of topic to be created
+   * \throws runtime_error if the Writer is not open.
+   */
+  void create_topic(const TopicWithType & topic_with_type) override;
+
+  /**
+   * Write a message to a bagfile. The topic needs to have been created before writing is possible.
+   *
+   * \param message to be written to the bagfile
+   * \throws runtime_error if the Writer is not open.
+   */
+  void write(std::shared_ptr<SerializedBagMessage> message) override;
+
+private:
+  rosbag2::StorageOptions options_;
+  rosbag2_storage::StorageFactory factory_;
+  std::shared_ptr<rosbag2_storage::storage_interfaces::ReadWriteInterface> storage_;
+};
+
+}  // namespace rosbag2
+
+#ifdef _WIN32
+# pragma warning(pop)
+#endif
+
+#endif  // ROSBAG2__WRITER_IMPL_HPP_

rosbag2/package.xml

@@ -20,6 +20,7 @@
   <test_depend>ament_lint_auto</test_depend>
   <test_depend>ament_lint_common</test_depend>
   <test_depend>test_msgs</test_depend>
+  <test_depend>rosbag2_storage_default_plugins</test_depend>
 
   <export>
     <build_type>ament_cmake</build_type>

rosbag2/src/rosbag2/writer.cpp → rosbag2/src/rosbag2/writer_impl.cpp

@@ -12,30 +12,33 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "rosbag2/writer.hpp"
+#include "rosbag2/writer_impl.hpp"
 
 #include <memory>
 #include <string>
 
+#include "rosbag2_storage/metadata_io.hpp"
 #include "rosbag2/storage_options.hpp"
 
 namespace rosbag2
 {
 
-Writer::~Writer()
+WriterImpl::~WriterImpl()
 {
+  rosbag2_storage::write_metadata(options_.uri + "metadata.yaml", storage_->get_metadata());
   storage_.reset();  // Necessary to ensure that the writer is destroyed before the factory
 }
 
-void Writer::open(const StorageOptions & options)
+void WriterImpl::open(const StorageOptions & options)
 {
   storage_ = factory_.open_read_write(options.uri, options.storage_id);
   if (!storage_) {
     throw std::runtime_error("No storage could be initialized. Abort");
   }
+  options_ = options;
 }
 
-void Writer::create_topic(const TopicWithType & topic_with_type)
+void WriterImpl::create_topic(const TopicWithType & topic_with_type)
 {
   if (!storage_) {
     throw std::runtime_error("Bag is not open. Call open() before writing.");
@@ -44,7 +47,7 @@ void Writer::create_topic(const TopicWithType & topic_with_type)
   storage_->create_topic(topic_with_type);
 }
 
-void Writer::write(std::shared_ptr<SerializedBagMessage> message)
+void WriterImpl::write(std::shared_ptr<SerializedBagMessage> message)
 {
   if (!storage_) {
     throw std::runtime_error("Bag is not open. Call open() before writing.");

rosbag2/test/rosbag2/temporary_directory_fixture.hpp

@@ -0,0 +1,103 @@
+// Copyright 2018, Bosch Software Innovations GmbH.
+//
+// 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 ROSBAG2__TEMPORARY_DIRECTORY_FIXTURE_HPP_
+#define ROSBAG2__TEMPORARY_DIRECTORY_FIXTURE_HPP_
+
+#include <gmock/gmock.h>
+
+#include <string>
+
+#ifdef _WIN32
+# include <direct.h>
+# include <Windows.h>
+#else
+# include <unistd.h>
+# include <sys/types.h>
+# include <dirent.h>
+#endif
+
+using namespace ::testing;  // NOLINT
+
+class TemporaryDirectoryFixture : public Test
+{
+public:
+  static void SetUpTestCase()
+  {
+    char template_char[] = "tmp_test_dir.XXXXXX";
+#ifdef _WIN32
+    char temp_path[255];
+    GetTempPathA(255, temp_path);
+    _mktemp_s(template_char, strnlen(template_char, 20) + 1);
+    temporary_dir_path_ = std::string(temp_path) + std::string(template_char);
+    _mkdir(temporary_dir_path_.c_str());
+#else
+    char * dir_name = mkdtemp(template_char);
+    temporary_dir_path_ = dir_name;
+#endif
+  }
+
+  static void TearDownTestCase()
+  {
+    remove_directory_recursively(temporary_dir_path_);
+  }
+
+  static void remove_directory_recursively(const std::string & directory_path)
+  {
+#ifdef _WIN32
+    // We need a string of type PCZZTSTR, which is a double null terminated char ptr
+    size_t length = strlen(directory_path.c_str());
+    TCHAR * temp_dir = new TCHAR[length + 2];
+    memcpy(temp_dir, temporary_dir_path_.c_str(), length);
+    temp_dir[length] = 0;
+    temp_dir[length + 1] = 0;  // double null terminated
+
+    SHFILEOPSTRUCT file_options;
+    file_options.hwnd = nullptr;
+    file_options.wFunc = FO_DELETE;  // delete (recursively)
+    file_options.pFrom = temp_dir;
+    file_options.pTo = nullptr;
+    file_options.fFlags = FOF_NOCONFIRMATION | FOF_SILENT;  // do not prompt user
+    file_options.fAnyOperationsAborted = FALSE;
+    file_options.lpszProgressTitle = nullptr;
+    file_options.hNameMappings = nullptr;
+
+    SHFileOperation(&file_options);
+    delete[] temp_dir;
+#else
+    DIR * dir = opendir(directory_path.c_str());
+    if (!dir) {
+      return;
+    }
+    struct dirent * directory_entry;
+    while ((directory_entry = readdir(dir)) != nullptr) {
+      // Make sure to not call ".." or "." entries in directory (might delete everything)
+      if (strcmp(directory_entry->d_name, ".") != 0 && strcmp(directory_entry->d_name, "..") != 0) {
+        if (directory_entry->d_type == DT_DIR) {
+          remove_directory_recursively(directory_path + "/" + directory_entry->d_name);
+        }
+        remove((directory_path + "/" + directory_entry->d_name).c_str());
+      }
+    }
+    closedir(dir);
+    remove(temporary_dir_path_.c_str());
+#endif
+  }
+
+  static std::string temporary_dir_path_;
+};
+
+std::string TemporaryDirectoryFixture::temporary_dir_path_ = "";  // NOLINT
+
+#endif  // ROSBAG2__TEMPORARY_DIRECTORY_FIXTURE_HPP_

rosbag2/test/rosbag2/test_writer.cpp

@@ -0,0 +1,55 @@
+// Copyright 2018, Bosch Software Innovations GmbH.
+//
+// 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 <gmock/gmock.h>
+
+#include <chrono>
+#include <fstream>
+#include <string>
+#include <thread>
+
+#include "rosbag2/storage_options.hpp"
+#include "rosbag2/writer_impl.hpp"
+#include "temporary_directory_fixture.hpp"
+
+using namespace ::testing;  // NOLINT
+using namespace std::chrono_literals;  // NOLINT
+
+void write_file(const std::string & uri)
+{
+  rosbag2::StorageOptions options = {uri, "sqlite3"};
+  rosbag2::WriterImpl writer;
+  writer.open(options);
+  writer.create_topic({"/string_topic", "topic/Type"});
+}
+
+std::string get_yaml_content(const std::string & filename)
+{
+  std::ifstream read_file(filename);
+  std::ostringstream ss;
+  ss << read_file.rdbuf();
+  return ss.str();
+}
+
+TEST_F(TemporaryDirectoryFixture, writer_writes_correct_yaml_at_shutdown) {
+  write_file(temporary_dir_path_ + "/test.bag");
+
+  std::string expected_start("rosbag2_bagfile_information:"
+    "\n  storage_identifier: sqlite3"
+    "\n  encoding: cdr");
+
+  // TODO(Martin-Idel-SI): This is not yet the correct file name
+  std::string actual_yaml = get_yaml_content(temporary_dir_path_ + "/test.bagmetadata.yaml");
+  ASSERT_THAT(actual_yaml, StartsWith(expected_start));
+}