snapshotManager.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2020 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
#pragma once

#ifdef WIN32
#include <winsock2.h>
#endif

#include "vrfcgf/vrfcgfDefines.h"
#include "vrfutil/vrfCallbackQueue.h"
#include "vrfutil/rwUUID.h"
#include <vrfutil/objectCounter.h>
#include <vrfmsgs/ifSnapshotsResponse.h>
#include "vrfutil/scenario.h"
#include "vrfmsgs/ifSaveScenario.h"
#include <vlpi/simulationAddress.h>
#include <sstream>
#include <vector>

#include <boost/unordered_map.hpp>

class DtCgf;
class DtPeriodicSnapshotSettings;
class DtSimMessage;
class DtVrfCallbackQueue;
class DtCompressedFileTransporter;

struct DT_DLL_vrfcgf DtInMemorySnapshot
#ifdef DtObjectDebugger_Enable
   : public DtObjectDebugger<DtInMemorySnapshot>
#endif
{
   DtInMemorySnapshot() : myId(0), mySimTime(0), myIsPeriodic(false) {};

   virtual ~DtInMemorySnapshot();

   int myId;
   double mySimTime;
   bool myIsPeriodic;

   typedef std::vector<std::string*> OOB;
   OOB myOob;
   std::string myPlans;
   std::string myScenarioExtras;
   std::string myScenarioScripts;
   std::string myOrbat;
   DtScenario myScenarioInformation;
};

DT_DEFINE_OBJECT_DEBUGGER_NAME(DtInMemorySnapshot);

class DT_DLL_vrfcgf DtSnapshotManager
{
private:
   DtSnapshotManager(const DtSnapshotManager&);
   DtSnapshotManager& operator=(const DtSnapshotManager&);

public:
   DtSnapshotManager(DtCgf* cgf);
   virtual ~DtSnapshotManager();

   virtual bool init();

   virtual void tick();

   virtual void setSimTime(double);

   virtual void enablePeriodicSnapshots(bool flag);
   virtual bool periodicSnapshotsEnabled() const;

   virtual void setSnapshotPeriod(double period);
   virtual double snapshotPeriod() const;

   virtual void setNumberOfSnapshotsToKeep(int);
   virtual int numberOfSnapshotsToKeep() const;

   virtual void setPauseCleanup(bool);
   bool pauseCleanup() const { return myPauseCleanup; }

   virtual void clear(bool allButBase = false);

   virtual bool isBaseSnapshot(DtInMemorySnapshot*) const;

   virtual DtInMemorySnapshot* takeSnapshot(bool isPeriodic = false, bool makeBase = false);

   virtual void rollbackToSimTime(double simTime);

   virtual void rollbackTo(DtInMemorySnapshot*, int scenarioRunId = 0);

   virtual void clearOutStaleSnapshots();

   virtual DtInMemorySnapshot* snapshotFor(int id) const;

   virtual void setSnapshotHeartbeatTime(double d);
   virtual double snapshotHeartbeatTime() const;

   virtual void sendCurrentSnapshots();

   virtual bool saveSnapshot(const DtFilename& saveFolder, DtCompressedFileTransporter& tr, DtIfSaveScenario* msg,
      const DtScenario& currentScenario, const DtSimulationAddress& requestor);

   virtual DtInMemorySnapshot* snapshotClosestToSimTime(double simTime) const;

   virtual void removeSnapshotsAfter(double simTime);

   virtual bool hasSnapshots() const;

   virtual void clearAllSnapshots();

protected:
   static void clearAllSnapshotsCallback(DtSimMessage*, void*);

   static void settingConsumerCallback(
      const DtSettingsObject* settingsObject, void* usr);
   virtual void processSettings(const DtPeriodicSnapshotSettings*);

   static void requestSnapshots(DtSimMessage*, void*);
   virtual void processSnapshotsRequest(DtSimMessage*);

   static void rollbackToSnapshot(DtSimMessage*, void*);
   virtual void processRollbackToSnapshot(DtSimMessage*);

   virtual void finishSavingSnapshots();

protected:
   class DtWriteSnapshotJob : public DtVrfCallbackQueue::CallbackInterface
   {
   public:
      DtWriteSnapshotJob(const DtSimulationAddress& addr,
         const DtIfSaveScenario& mess, DtInMemorySnapshot* snapshot, DtCompressedFileTransporter&);
      virtual ~DtWriteSnapshotJob();
      virtual void run();

      DtSimulationAddress myRequestor;
      DtIfSaveScenario mySaveMessage;
      DtInMemorySnapshot* mySnapshot;
      DtCompressedFileTransporter& myTransporter;
      bool mySuccess;

   protected:
      virtual bool writeAndSendOrderOfBattleFile();
      virtual bool writeAndSendPlanFile();
      virtual bool writeAndSendScenarioExtrasFile();
      virtual bool writeAndSendScenarioScriptsFile();
      virtual bool writeAndSendOrbatFile();
   };

protected:
   DtCgf* myCgf;
   bool myPeriodicSnapshotsEnabled;
   double mySnapshotPeriod;
   double myLastSnapshotHeartbeat;
   double mySnapshotHeartbeatTime;
   double myLastTimePeriodicSnapshoted;
   int myNumberOfSnapshotsToKeep;
   int myNextSnapshotId;

   typedef std::map<int, DtInMemorySnapshot*> Snapshots;
   Snapshots mySnapshots;
   Snapshots myPeriodicSnapshots;

   bool mySnapshotsModified;

   DtIfSnapshotsResponse myCurrentSnapshots;

   bool myPauseCleanup;

   typedef std::map<int, DtVrfCallbackQueue::CallbackInterface::Ptr> SavingSnapshots;
   SavingSnapshots myCheckpointing;

   DtVrfCallbackQueue* myFileWriterJobQueue;
};