amps-python-client 5.3.4.1__zip → 5.3.4.3__zip

amps-python-client-5.3.4.3/src/cpp/include/amps/RecoveryPointAdapter.hpp

@@ -0,0 +1,501 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2010-2024 60East Technologies Inc., All Rights Reserved.
+//
+// This computer software is owned by 60East Technologies Inc. and is
+// protected by U.S. copyright laws and other laws and by international
+// treaties.  This computer software is furnished by 60East Technologies
+// Inc. pursuant to a written license agreement and may be used, copied,
+// transmitted, and stored only in accordance with the terms of such
+// license agreement and with the inclusion of the above copyright notice.
+// This computer software or any other copies thereof may not be provided
+// or otherwise made available to any other person.
+//
+// U.S. Government Restricted Rights.  This computer software: (a) was
+// developed at private expense and is in all respects the proprietary
+// information of 60East Technologies Inc.; (b) was not developed with
+// government funds; (c) is a trade secret of 60East Technologies Inc.
+// for all purposes of the Freedom of Information Act; and (d) is a
+// commercial item and thus, pursuant to Section 12.212 of the Federal
+// Acquisition Regulations (FAR) and DFAR Supplement Section 227.7202,
+// Government's use, duplication or disclosure of the computer software
+// is subject to the restrictions set forth by 60East Technologies Inc..
+//
+////////////////////////////////////////////////////////////////////////////
+
+#ifndef _RECOVERYPOINTADAPTER_H_
+#define _RECOVERYPOINTADAPTER_H_
+
+#include <amps/Field.hpp>
+#include <amps/RecoveryPoint.hpp>
+#include <vector>
+#include <iterator>
+#include <memory>
+#include <thread>
+#include <unordered_map>
+#if __cplusplus >= 201100L || _MSC_VER >= 1900
+  #include <atomic>
+#endif
+
+/// \file RecoveryPointAdapter.hpp
+/// \brief Provides AMPS::RecoveryPointAdapter, an iterface for implementing
+/// external storage of bookmark subscription recovery data
+/// and for recovering from that external storage.
+
+namespace AMPS
+{
+
+  class RecoveryPointAdapter;
+
+/// RecoveryPointAdapterImpl virtual base class for implementing external
+/// storage of subscription recovery points and recovery from storage.
+  class RecoveryPointAdapterImpl : public RefBody
+  {
+  public:
+    virtual ~RecoveryPointAdapterImpl() { }
+    /// Recovery is done by iteration over elements in storage. This function
+    /// modifies the passed in argument to be the next stored RecoveryPoint
+    /// or an empty RecoveryPoint to indicate completion.
+    /// \param current_ The RecoveryPoint to set as the next recovery item.
+    virtual bool next(RecoveryPoint& current_) = 0;
+    /// Update the storage information with the given recovery point.
+    /// \param recoveryPoint_ The new/updated RecoveryPoint to save.
+    virtual void update(RecoveryPoint& recoveryPoint_) = 0;
+    /// Remove all data from the storage
+    virtual void purge() = 0;
+    /// Remove the specified subId_ from the storage
+    /// \param subId_ The sub id to remove
+    virtual void purge(const Field& subId_) = 0;
+    /// Take any necessary actions to close the associated storage.
+    virtual void close() = 0;
+    /// Take any necessary actions to reduce associated storage size.
+    virtual void prune() { ; }
+  };
+
+/// RecoveryPointAdapter a handle class for implementing external
+/// storage of subscription recovery points and recovery from storage.
+  class RecoveryPointAdapter // -V690
+  {
+  public:
+    class iterator
+    {
+      RecoveryPointAdapterImpl* _pAdapter;
+      RecoveryPoint _current;
+      inline void advance()
+      {
+        if (!_pAdapter || !_pAdapter->next(_current))
+        {
+          _pAdapter = NULL;
+        }
+      }
+
+    public:
+      iterator() // end
+        : _pAdapter(NULL)
+      {;}
+      iterator(RecoveryPointAdapterImpl* pAdapter_)
+        : _pAdapter(pAdapter_)
+      {
+        advance();
+      }
+
+      bool operator==(const iterator& rhs) const
+      {
+        return _pAdapter == rhs._pAdapter;
+      }
+      bool operator!=(const iterator& rhs) const
+      {
+        return _pAdapter != rhs._pAdapter;
+      }
+      void operator++(void)
+      {
+        advance();
+      }
+      RecoveryPoint operator*(void)
+      {
+        return _current;
+      }
+      RecoveryPoint* operator->(void)
+      {
+        return &_current;
+      }
+    };
+
+    RecoveryPointAdapter() : _body() { }
+    RecoveryPointAdapter(RecoveryPointAdapterImpl* body_, bool isRef_ = true)
+      : _body(body_, isRef_) { }
+    RecoveryPointAdapter(const RecoveryPointAdapter& rhs_)
+      : _body(rhs_._body)
+    { }
+
+    /// To recover from an adapter, iterate over the adapter from begin() to
+    /// end() with a RecoveryPointIterator. Calling *iter should yield a
+    /// RecoveryPoint&.
+    /// Begin recovery from storage and return an iterator to the first
+    /// RecoveryPoint or end() if there are none.
+    /// \return The iterator for the first RecoveryPoint or end() if empty.
+    iterator begin()
+    {
+      return iterator(&(_body.get()));
+    }
+
+    /// Return the end of recovery marker.
+    /// \return The iterator marking the end of recovery.
+    iterator end()
+    {
+      return iterator();
+    }
+
+    /// Update the storage information with the given recovery point.
+    /// \param recoveryPoint_ The new/updated RecoveryPoint to save.
+    void update(RecoveryPoint& recoveryPoint_)
+    {
+      _body.get().update(recoveryPoint_);
+    }
+
+    /// Remove all data from the storage
+    void purge()
+    {
+      _body.get().purge();
+    }
+
+    /// Remove the specified subId_ from the storage
+    /// \param subId_ The sub id to remove
+    void purge(const Field& subId_)
+    {
+      _body.get().purge(subId_);
+    }
+
+    /// Take any necessary actions to close the associated storage.
+    void close()
+    {
+      _body.get().close();
+    }
+
+    /// Take any necessary actions to close the associated storage.
+    void prune()
+    {
+      _body.get().prune();
+    }
+
+    /// Return if this has a valid implementation.
+    bool isValid() const
+    {
+      return _body.isValid();
+    }
+  private:
+    BorrowRefHandle<RecoveryPointAdapterImpl> _body;
+  };
+
+/// RecoveryPointAdapter implementation that delegates storage to another
+/// RecoveryPointAdapter but provides conflation so that only every X updates
+/// are saved and/or only the last update every Y milliseconds is saved.
+  class ConflatingRecoveryPointAdapter : public RecoveryPointAdapterImpl
+  {
+  public:
+    /// Conflate updates to delegate_ where they will only be processed
+    /// every updateIntervalMillis_ for subscriptions that have been updated
+    /// at least updateThreshold_ times or haven't been updated for at least
+    /// timeoutMillis_ milliseconds.
+    /// \param delegate_ A shared pointer to the underlying delegate
+    /// RecoveryPointAdapter.
+    /// \param updateThreshold_ The minimum number of updates for a given subId
+    /// before a conflated update is delivered. Setting to 1 will prevent
+    /// conflation from occurring.
+    /// \param timeoutMillis_ The maximum amount of time between conflated
+    /// updates for a given subId. Setting to 0 will force all updates to be
+    /// sent any time one update needs to be sent or every updateInterval.
+    /// \param updateIntervalMillis_ The amount of time the update thread can
+    /// sit idle between sending conflated updates and checking for timeouts.
+    ConflatingRecoveryPointAdapter(
+      const std::shared_ptr<RecoveryPointAdapterImpl>& delegate_,
+      unsigned updateThreshold_ = 10,
+      double timeoutMillis_ = 2000.0,
+      long updateIntervalMillis_ = 2000
+    )
+      : _delegate(delegate_)
+      , _updateThreshold(updateThreshold_)
+      , _timeoutMillis(timeoutMillis_)
+      , _updateIntervalMillis(updateIntervalMillis_)
+      , _closed(false)
+      , _updateAll(false)
+    {
+      // Start the update thread
+      _thread = std::thread(&ConflatingRecoveryPointAdapter::updateThread,
+                            this);
+    }
+
+    virtual ~ConflatingRecoveryPointAdapter()
+    {
+      _close();
+      _thread.join();
+      for (UpdateIter purged = _latestUpdates.begin();
+           purged != _latestUpdates.end(); ++purged)
+      {
+        Field clearableSubId = purged->first;
+        purged->second.clear();
+        clearableSubId.clear();
+      }
+    }
+
+    /// Recovery is done by iteration over elements in storage. This function
+    /// modifies the passed in argument to be the next stored RecoveryPoint
+    /// or an empty RecoveryPoint to indicate completion.
+    /// \param current_ The RecoveryPoint to set as the next recovery item.
+    virtual bool next(RecoveryPoint& current_)
+    {
+      return _delegate->next(current_);
+    }
+
+    /// Update the storage information with the given recovery point.
+    /// \param recoveryPoint_ The new/updated RecoveryPoint to save.
+    virtual void update(RecoveryPoint& recoveryPoint_)
+    {
+      Field subId = recoveryPoint_.getSubId();
+      Lock<Mutex> lock(_lock);
+      UpdateIter lastUpdate = _latestUpdates.find(subId);
+      if (lastUpdate == _latestUpdates.end())
+      {
+        // New sub id, use deep copies and a new Timer.
+        subId = subId.deepCopy();
+        _latestUpdates[subId] = recoveryPoint_.deepCopy();
+        _counts[subId] = 1;
+        if (_timeoutMillis != 0.0) // -V550
+        {
+          Timer timer(_timeoutMillis);
+          timer.start();
+          _timers[subId] = timer;
+        }
+      }
+      else
+      {
+        // SubId already exists, set to new recovery point.
+        lastUpdate->second.deepCopy(recoveryPoint_);
+        // Increment and check the count.
+        if (++_counts[subId] >= _updateThreshold)
+        {
+          // Time to update, make sure update thread wakes up.
+          _lock.signalAll();
+        }
+      }
+    }
+
+    /// Remove all data from the storage.
+    virtual void purge()
+    {
+      _delegate->purge();
+      Lock<Mutex> lock(_lock);
+      _counts.clear();
+      _timers.clear();
+      for (UpdateIter purged = _latestUpdates.begin();
+           purged != _latestUpdates.end(); ++purged)
+      {
+        Field clearableSubId = purged->first;
+        purged->second.clear();
+        clearableSubId.clear();
+      }
+      _latestUpdates.clear();
+    }
+
+    /// Remove the specified subId_ from the storage.
+    /// \param subId_ The sub id to remove.
+    virtual void purge(const Field& subId_)
+    {
+      _delegate->purge(subId_);
+      Lock<Mutex> lock(_lock);
+      UpdateIter purged = _latestUpdates.find(subId_);
+      if (purged != _latestUpdates.end())
+      {
+        Field clearableSubId = purged->first;
+        purged->second.clear();
+        _latestUpdates.erase(purged);
+        _counts.erase(subId_);
+        _timers.erase(subId_);
+        clearableSubId.clear();
+      }
+    }
+
+    /// Take any necessary actions to close the associated storage.
+    virtual void close()
+    {
+      _close();
+    }
+
+    /// Push all updates to underlying adapter.
+    virtual void updateAll()
+    {
+      Lock<Mutex> lock(_lock);
+      _runUpdateAll();
+    }
+
+    /// Lock is already held
+    virtual void _runUpdateAll()
+    {
+      _updateAll = true;
+      while (!_counts.empty())
+      {
+        _lock.signalAll();
+        _lock.wait(250);
+      }
+    }
+
+  protected:
+    void _close()
+    {
+      // Save all cached updates before shutting down update thread.
+      if (!_closed)
+      {
+        Lock<Mutex> lock(_lock);
+        _runUpdateAll();
+        _closed = true;
+        _lock.signalAll();
+      }
+      _delegate->close();
+    }
+    void updateThread()
+    {
+      // A place to hold updates to save
+      std::vector<SavedUpdate> _queuedUpdates;
+      while (!_closed)
+      {
+        DeferLock<Mutex> lock(_lock);
+        lock.lock();
+        // Wait for a signal or update interval
+        _lock.wait(_updateIntervalMillis);
+
+        // Check for timeouts
+        for (TimerMap::iterator timer = _timers.begin();
+             timer != _timers.end(); )
+        {
+          if (timer->second.check())
+          {
+            UpdateIter update = _latestUpdates.find(timer->first);
+            if (update != _latestUpdates.end())
+            {
+              // Remove subId from all, clear of subId will
+              // occur after save.
+              _queuedUpdates.push_back(*update);
+              _counts.erase(update->first);
+              timer = _timers.erase(timer);
+              _latestUpdates.erase(update);
+            }
+            else
+            {
+              ++timer;
+            }
+          }
+          else
+          {
+            ++timer;
+          }
+        }
+
+        // Need a local version so it doesn't change after we unlock to
+        // deliver updates.
+        bool updateAll = (bool)_updateAll;
+        // Check for update counts
+        for (CountMap::iterator count = _counts.begin();
+             count != _counts.end(); )
+        {
+          if (updateAll || _timeoutMillis == 0.0 // -V550
+              || count->second >= _updateThreshold)
+          {
+            UpdateIter update = _latestUpdates.find(count->first);
+            if (update != _latestUpdates.end())
+            {
+              // Remove subId from all, clear of subId will
+              // occur after save.
+              _queuedUpdates.push_back(*update);
+              count = _counts.erase(count);
+              _timers.erase(update->first);
+              _latestUpdates.erase(update);
+            }
+            else
+            {
+              ++count;
+            }
+          }
+          else
+          {
+            ++count;
+          }
+        }
+        // Release the lock unless we're doing an update all, then we
+        // hold it until updates are completed and signal when done.
+        if (!updateAll)
+        {
+          lock.unlock();
+        }
+        // Shouldn't need the lock to send the updates
+        for (std::vector<SavedUpdate>::iterator update = _queuedUpdates.begin(), end = _queuedUpdates.end(); update != end; ++update)
+        {
+          _delegate->update(update->second);
+          Field clearableSubId(update->first);
+          clearableSubId.clear();
+          update->second.clear();
+        }
+        _queuedUpdates.clear();
+        if (updateAll)
+        {
+          _updateAll = false;
+          _lock.signalAll();
+        }
+      } // -V1020
+    }
+
+    // The adapter doing the real saves
+    std::shared_ptr<RecoveryPointAdapterImpl> _delegate;
+
+    // Lock used to protect _latestUpdates, _timers, and _counts.
+    Mutex                                     _lock;
+
+    // Types for our maps
+    typedef std::unordered_map<Field, RecoveryPoint, Field::FieldHash> UpdateMap;
+    typedef std::pair<Field, RecoveryPoint>                       SavedUpdate;
+    typedef UpdateMap::value_type                                 Update;
+    typedef UpdateMap::iterator                                   UpdateIter;
+    typedef std::unordered_map<Field, Timer, Field::FieldHash>    TimerMap;
+    typedef TimerMap::iterator                                    TimerIter;
+    typedef std::unordered_map<Field, unsigned, Field::FieldHash> CountMap;
+    typedef CountMap::iterator                                    CountIter;
+
+    // Saves the most recent update for each sub id.
+    UpdateMap                                 _latestUpdates;
+
+    // Saves a timer for each sub id that is reset each time we save.
+    TimerMap                                  _timers;
+
+    // Saves a count of how many updates have come in since last save.
+    CountMap                                  _counts;
+
+    // The thread doing the saves.
+    std::thread                               _thread;
+
+    // How many updates before we force a save.
+    unsigned                                  _updateThreshold;
+
+    // How long between getting first cached update and save.
+    double                                    _timeoutMillis;
+
+    // How long between automatic checks of the timers.
+    long                                      _updateIntervalMillis;
+
+#if __cplusplus >= 201100L || _MSC_VER >= 1900
+    // The update thread runs until this is true.
+    std::atomic<bool>                         _closed;
+
+    // Flag to tell update thread to save everything.
+    std::atomic<bool>                         _updateAll;
+#else
+    // The update thread runs until this is true.
+    volatile bool                             _closed;
+
+    // Flag to tell update thread to save everything.
+    volatile bool                             _updateAll;
+#endif
+  };
+
+}
+
+#endif //_RECOVERYPOINTADAPTER_H_
+