Initial commit

Lts/Common/PluginInterfaces/record_replay_plugin.h

@@ -0,0 +1,157 @@
+/**
+  * @RDE_HEADER@
+  * Provide Record/Replay functionality for dds topics in a service
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Christian Ehrlicher, SLSE, 2016-07-07
+  */
+
+#pragma once
+
+#include <memory>
+#include <map>
+#include <QObject>
+#include <QString>
+#include <QHash>
+
+namespace DDSConnector
+{
+class DdsConnector;
+}
+
+class NSqlQuery;
+namespace RecordReplay
+{
+class RecordReplayPlugin
+{
+public:
+  RecordReplayPlugin() = default;
+  virtual ~RecordReplayPlugin() = default;
+
+  virtual QString pluginName() const = 0;
+
+  /**
+   * @brief initialize all data topic clients for the topics to record (for record management)
+   * @return true on success
+   */
+  virtual bool initDtc(const std::shared_ptr<DDSConnector::DdsConnector> &ddsConnector,
+                       int exerciseId) = 0;
+  /**
+   * @brief initialize all data topic server for the topics to replay (for situation replay)
+   * @return true on success
+   */
+  virtual bool initDts(const std::shared_ptr<DDSConnector::DdsConnector> &ddsConnector,
+                       int exerciseId,
+                       bool bCanHandleSchemas,
+                       NSqlQuery &query) = 0;
+
+  /**
+   * @brief initialize the plugin for copying data from one database to another
+   * @return true on success
+   */
+  virtual bool initCopy(int exerciseId, bool bCanHandleSchemasRead, bool bCanHandleSchemasWrite) = 0;
+
+  /**
+   * @brief copy all recorded data from one database to another
+   * @param queryFrom a NSqlQuery which has a database connection to the database to read from
+   * @param queryToa NSqlQuery which has a database connection to the database to write to
+   * @param fromTime start time of the data to copy
+   * @param toTime end time of the data to copy
+   * @return true on success
+   */
+  virtual bool copyData(NSqlQuery &queryFrom, NSqlQuery &queryTo, qint64 fromTime, qint64 toTime) = 0;
+
+  /**
+    * @brief get the service short name used in rec_snaphsot.svc_name)
+    */
+  virtual QString svcShortName() const = 0;
+
+  // recording functions
+  /**
+   * @brief Read data from dds and save it to the corresponding tables
+   * @param query the NSqlQuery to use (speedup to not create a query on every call)
+   * @param minRecordSampleTime the minimum sample time seen during this call
+   * @return true on success (can only be false on wrong schema)
+   */
+  virtual bool ddsTopicsToDatabase(NSqlQuery &query, QHash<QString, qint64> &minRecordSampleTimes) = 0;
+  // publishing functions
+  /**
+   * @brief Read all data to be able to publish all topics with the correct for the given start time
+   * @param query the NSqlQuery to use (speedup to not create a query on every call)
+   * @param startTime the timestamp for which the replay should be started
+   * @return true on success
+   */
+  virtual bool setReplayStartTime(NSqlQuery &query, qint64 startTime) = 0;
+  /**
+   * @brief Read data from database and store it in internal buffers for a specific time stamp
+   * @param query the NSqlQuery to use (speedup to not create a query on every call)
+   * @param fromTime lower time for range to read (including)
+   * @param toTime higher time for range to read (excluding)
+   * @return true on success
+   */
+  virtual bool ddsTopicsFromDatabase(NSqlQuery &query, qint64 fromTime, qint64 toTime) = 0;
+  /**
+   * @brief publish all data in the internal buffers to dds until the desired time is reached
+   * @param desiredTime last timestamp to publish data for
+   * @return true on success
+   */
+  virtual bool publishData(qint64 desiredTime) = 0;
+  /**
+   * @brief wait for possible asnyc operations which must be finished for the given time and publish this data
+   * @param desiredTime last timestamp to publish data for
+   * @return true on success
+   */
+  virtual bool waitForAsyncOperations(qint64 desiredTime) { Q_UNUSED(desiredTime); return true; }
+  /**
+   * @brief clear the internal buffer (filled by ddsTopicsFromDatabase()) - e.g. for a new starting point
+   * also remove the data from dds
+   */
+  virtual void clearData() = 0;
+
+  // structure/functions for snapshot creation
+  struct RecSnapshot  // see rec_db.h / RecSnapshot
+  {
+    qint64 timeStamp = 0;
+    std::map<int64_t, int64_t> recIdArray;
+    RecSnapshot() = default;
+    RecSnapshot(qint64 timeStamp_, const std::map<int64_t, int64_t> &recIdArray_)
+      : timeStamp(timeStamp_)
+      , recIdArray(recIdArray_)
+    {}
+  };
+  /**
+   * @brief Run through the given time range with the given interval and collect the latest database entries (id, key) for snapshot creation
+   * @param query the NSqlQuery to use (speedup to not create a query on every call)
+   * @param fromTime lower time for range to read (including)
+   * @param toTime higher time for range to read (excluding)
+   * @param interval sanpshot creation interval
+   * @return snapshots to create
+   */
+  virtual std::map<QString, std::vector<RecSnapshot>> getSnapshotTimes(NSqlQuery &query,
+                                                                       qint64 toTime,
+                                                                       qint64 interval,
+                                                                       const QHash<QString, qint64> &minRecordedSampleTimes) = 0;
+
+  /**
+   * @brief Return all topics which are handled (= recorded/replayed) by this plugin
+   */
+  virtual QVector<QString> getRecordTopicNames() const = 0;
+
+  /**
+   * @brief Return all record/replay tables
+   */
+  virtual QVector<QString> getRecordTableNames() const = 0;
+
+  /**
+   * @brief "SELECT min(sample_time) FROM rec_<topic_name>"
+   * @param query the NSqlQuery to use (speedup to not create a query on every call)
+   * @param topicName the topic to get the minimum sample time for
+   * @param defaultValue the default value if no sample is found
+   * @return
+   */
+  virtual qint64 getMinimumSampleTime(NSqlQuery &q, const QString &topicName, qint64 defaultValue) const = 0;
+};
+}
+
+Q_DECLARE_INTERFACE(RecordReplay::RecordReplayPlugin, "special:3:recordreplay")