Test PR for new Retry Framework

HeterogeneousCore/SonicCore/interface/RetryActionBase.h

@@ -0,0 +1,33 @@
+#ifndef RETRY_ACTION_BASE_H
+#define RETRY_ACTION_BASE_H
+
+#include "FWCore/PluginManager/interface/PluginFactory.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "HeterogeneousCore/SonicCore/interface/SonicClientBase.h"
+#include <memory>
+#include <string>
+
+// Base class for retry actions
+class RetryActionBase {
+public:
+  RetryActionBase(const edm::ParameterSet& conf, SonicClientBase* client);
+  virtual ~RetryActionBase() = default;
+
+  bool shouldRetry() const { return shouldRetry_; }  // Getter for shouldRetry_
+
+  virtual void retry() = 0;  // Pure virtual function for execution logic
+  virtual void start() = 0;  // Pure virtual function for execution logic for initialization
+
+protected:
+  void eval();               // interface for calling evaluate in client
+
+protected:
+  SonicClientBase* client_;
+  bool shouldRetry_;  // Flag to track if further retries should happen
+};
+
+// Define the factory for creating retry actions
+using RetryActionFactory =
+    edmplugin::PluginFactory<RetryActionBase*(const edm::ParameterSet&, SonicClientBase* client)>;
+
+#endif  // RETRY_ACTION_BASE_H

HeterogeneousCore/SonicCore/interface/RetrySameServerAction.h

@@ -0,0 +1,16 @@
+#include "HeterogeneousCore/SonicCore/interface/RetryActionBase.h"
+#include "HeterogeneousCore/SonicCore/interface/SonicClientBase.h"
+
+class RetrySameServerAction : public RetryActionBase {
+public:
+  RetrySameServerAction(const edm::ParameterSet& pset, SonicClientBase* client)
+      : RetryActionBase(pset, client), allowedTries_(pset.getUntrackedParameter<unsigned>("allowedTries", 0)) {}
+
+  void start() override { tries_=0;};
+
+protected:
+  void retry() override;
+
+private:
+  unsigned allowedTries_, tries_;
+};

HeterogeneousCore/SonicCore/interface/SonicClientBase.h

@@ -9,12 +9,15 @@
 #include "HeterogeneousCore/SonicCore/interface/SonicDispatcherPseudoAsync.h"
 
 #include <string>
+#include <vector>
 #include <exception>
 #include <memory>
 #include <optional>
 
 enum class SonicMode { Sync = 1, Async = 2, PseudoAsync = 3 };
 
+class RetryActionBase;
+
 class SonicClientBase {
 public:
   //constructor
@@ -57,11 +60,20 @@ class SonicClientBase {
   unsigned allowedTries_, tries_;
   std::optional<edm::WaitingTaskWithArenaHolder> holder_;
 
+  // Use a unique_ptr with a custom deleter to avoid incomplete type issues
+  struct RetryDeleter {
+      void operator()(RetryActionBase* ptr) const;
+  };
+
+  using RetryActionPtr = std::unique_ptr<RetryActionBase, RetryDeleter>;
+  std::vector<RetryActionPtr> retryActions_;
+
   //for logging/debugging
   std::string debugName_, clientName_, fullDebugName_;
 
   friend class SonicDispatcher;
   friend class SonicDispatcherPseudoAsync;
+  friend class RetryActionBase;
 };
 
 #endif

HeterogeneousCore/SonicCore/src/RetryActionBase.cc

@@ -0,0 +1,14 @@
+#include "HeterogeneousCore/SonicCore/interface/RetryActionBase.h"
+
+// Constructor implementation
+RetryActionBase::RetryActionBase(const edm::ParameterSet& conf, SonicClientBase* client) : client_(client), shouldRetry_(true)  {}
+
+void RetryActionBase::eval() {
+  if (client_) {
+    client_->evaluate();
+  } else {
+    edm::LogError("RetryActionBase") << "Client pointer is null, cannot evaluate.";
+  }
+}
+
+EDM_REGISTER_PLUGINFACTORY(RetryActionFactory, "RetryActionFactory");

HeterogeneousCore/SonicCore/src/RetrySameServerAction.cc

@@ -0,0 +1,16 @@
+#include "HeterogeneousCore/SonicCore/interface/RetrySameServerAction.h"
+#include "HeterogeneousCore/SonicCore/interface/SonicClientBase.h"
+
+void RetrySameServerAction::retry() {
+  ++tries_;
+  //if max retries has not been exceeded, call evaluate again
+  if (tries_ < allowedTries_) {
+    eval();
+    return;
+  }else{
+     shouldRetry_ = false;  // Flip flag when max retries are reached
+     edm::LogInfo("RetrySameServerAction") << "Max retry attempts reached. No further retries.";
+  }
+}
+
+DEFINE_EDM_PLUGIN(RetryActionFactory, RetrySameServerAction, "RetrySameServerAction");

HeterogeneousCore/SonicCore/src/SonicClientBase.cc

@@ -1,7 +1,14 @@
 #include "HeterogeneousCore/SonicCore/interface/SonicClientBase.h"
+#include "HeterogeneousCore/SonicCore/interface/RetryActionBase.h"
 #include "FWCore/Utilities/interface/Exception.h"
 #include "FWCore/ParameterSet/interface/allowedValues.h"
 
+
+// Custom deleter implementation
+void SonicClientBase::RetryDeleter::operator()(RetryActionBase* ptr) const {
+    delete ptr;
+}
+
 SonicClientBase::SonicClientBase(const edm::ParameterSet& params,
                                  const std::string& debugName,
                                  const std::string& clientName)
@@ -12,6 +19,18 @@ SonicClientBase::SonicClientBase(const edm::ParameterSet& params,
   if (!clientName_.empty())
     fullDebugName_ += ":" + clientName_;
 
+  std::vector<edm::ParameterSet> retryPSetList = params.getParameter<std::vector<edm::ParameterSet>>("Retry");
+
+  for (const auto& retryPSet : retryPSetList) {
+        std::string actionType = retryPSet.getParameter<std::string>("retryType");
+
+        auto retryAction = RetryActionFactory::get()->create(actionType, retryPSet, this);
+        if (retryAction) {
+            //Convert to  RetryActionPtr Type from raw pointer of retryAction 
+            retryActions_.emplace_back(RetryActionPtr(retryAction.release()));
+        }
+  }
+
   std::string modeName(params.getParameter<std::string>("mode"));
   if (modeName == "Sync")
     setMode(SonicMode::Sync);
@@ -40,19 +59,39 @@ void SonicClientBase::start(edm::WaitingTaskWithArenaHolder holder) {
   holder_ = std::move(holder);
 }
 
-void SonicClientBase::start() { tries_ = 0; }
+void SonicClientBase::start() { 
+    tries_ = 0; 
+    // initialize all actions
+    for (const auto& action : retryActions_) {
+        action->start();
+    }
+}
 
 void SonicClientBase::finish(bool success, std::exception_ptr eptr) {
   //retries are only allowed if no exception was raised
   if (!success and !eptr) {
-    ++tries_;
-    //if max retries has not been exceeded, call evaluate again
-    if (tries_ < allowedTries_) {
-      evaluate();
-      //avoid calling doneWaiting() twice
-      return;
+    //++tries_;
+    ////if max retries has not been exceeded, call evaluate again
+    //if (tries_ < allowedTries_) {
+    //  evaluate();
+    //  //avoid calling doneWaiting() twice
+    //  return;
+    //}
+
+    // Check if any retry actions are still valid
+    bool anyRetryAllowed = false;
+    for (const auto& action : retryActions_) {
+        if (action->shouldRetry()) {
+            action->retry();  // Call retry only if shouldRetry_ is true
+            return;
+        }
+    }
+    // If no actions allow retries, stop retrying
+    if (!anyRetryAllowed) {
+        edm::LogInfo("SonicClientBase") << "No retry actions available. Stopping retries.";
+        return;
     }
-    //prepare an exception if exceeded
+    //prepare an exception if no more retries left
     else {
       edm::Exception ex(edm::errors::ExternalFailure);
       ex << "SonicCallFailed: call failed after max " << tries_ << " tries";