add strategies api for getting a strategy during remap plugin init

Author: traeak

include/proxy/http/remap/RemapConfig.h

@@ -76,6 +76,9 @@ struct BUILD_TABLE_INFO {
   // noncopyable
   BUILD_TABLE_INFO(const BUILD_TABLE_INFO &)            = delete; // disabled
   BUILD_TABLE_INFO &operator=(const BUILD_TABLE_INFO &) = delete; // disabled
+
+  // This is used to expose rewrite and its next hop strategy factory.
+  inline static BUILD_TABLE_INFO *instance = nullptr;
 };
 
 const char *remap_parse_directive(BUILD_TABLE_INFO *bti, char *errbuf, size_t errbufsize);

include/ts/ts.h

@@ -1616,6 +1616,19 @@ void const *TSHttpTxnNextHopStrategyGet(TSHttpTxn txnp);
  */
 char const *TSHttpNextHopStrategyNameGet(void const *strategy);
 
+/**
+    Retrieves a pointer to the named strategy in the strategy table.
+                This can only be called during TSRemapNewInstance.
+    Returns nullptr if no strategy found.
+    This uses the current RemapInit NextHopStrategyFactory.
+
+                This strategy pointer can still be used by all following transactions.
+
+    @param name of the strategy to look up.
+
+ */
+void const *TSHttpInitNextHopNamedStrategyGet(const char *name);
+
 /**
     Retrieves a pointer to the named strategy in the strategy table.
     Returns nullptr if no strategy is set.

plugins/header_rewrite/operators.cc

@@ -1636,44 +1636,43 @@ void
 OperatorSetNextHopStrategy::initialize(Parser &p)
 {
   Operator::initialize(p);
+  _stratname = p.get_arg();
 
-  _value.set_value(p.get_arg(), this);
-  Dbg(pi_dbg_ctl, "OperatorSetNextHopStrategy::initialie: %s", _value.get_value().c_str());
+  if (_stratname.empty() || "null" == _stratname) {
+    Dbg(pi_dbg_ctl, "OperatorSetNextHopStrategy::initialize: 'clear'");
+  } else {
+    _strategy = TSHttpInitNextHopNamedStrategyGet(_stratname.c_str());
+    if (nullptr == _strategy) {
+      TSWarning("[%s] Failed to get strategy '%s'", PLUGIN_NAME, _stratname.c_str());
+      _apply = false;
+    } else {
+      Dbg(pi_dbg_ctl, "OperatorSetNextHopStrategy::initialize: '%s'", _stratname.c_str());
+    }
+  }
 }
 
 void
 OperatorSetNextHopStrategy::initialize_hooks()
 {
-  add_allowed_hook(TS_HTTP_READ_REQUEST_HDR_HOOK);
   add_allowed_hook(TS_REMAP_PSEUDO_HOOK);
 }
 
 bool
 OperatorSetNextHopStrategy::exec(const Resources &res) const
 {
-  if (!res.state.txnp) {
-    TSError("[%s] OperatorSetNextHopStrategy() failed. Transaction is null", PLUGIN_NAME);
-  }
-
-  auto const txnp = res.state.txnp;
-
-  std::string value;
-  _value.append_value(value, res);
-
-  // Setting an empty strategy clears it for either parent.config or remap to
-  if ("null" == value || value.empty()) {
-    Dbg(pi_dbg_ctl, "Clearing strategy");
-    TSHttpTxnNextHopStrategySet(txnp, nullptr);
+  if (!_apply) {
+    Dbg(pi_dbg_ctl, "OperatorSetNextHopStrategy::exec: do nothing");
     return true;
   }
+  auto const txnp = res.state.txnp;
 
-  void const *const stratptr = TSHttpTxnNextHopNamedStrategyGet(txnp, value.c_str());
-  if (nullptr == stratptr) {
-    TSWarning("[%s] Failed to get strategy '%s'", PLUGIN_NAME, value.c_str());
+  if (nullptr == _strategy) {
+    Dbg(pi_dbg_ctl, "OperatorSetNextHopStrategy::exec: Clearing strategy");
   } else {
-    Dbg(pi_dbg_ctl, "   Setting strategy '%s'", value.c_str());
-    TSHttpTxnNextHopStrategySet(txnp, stratptr);
+    Dbg(pi_dbg_ctl, "OperatorSetNextHopStrategy::exec: Setting strategy to '%s'", _stratname.c_str());
   }
 
+  TSHttpTxnNextHopStrategySet(txnp, _strategy);
+
   return true;
 }

plugins/header_rewrite/operators.h

@@ -668,5 +668,7 @@ class OperatorSetNextHopStrategy : public Operator
   bool exec(const Resources &res) const override;
 
 private:
-  Value _value;
+  bool        _apply = true;
+  std::string _stratname;
+  void const *_strategy = nullptr;
 };

plugins/regex_remap/regex_remap.cc

@@ -227,12 +227,17 @@ class RemapRegex
     return _lowercase_substitutions;
   }
   inline bool
-  has_strategy() const
+  has_strategy_option() const
   {
     return _has_strategy;
   }
   inline std::string const &
-  strategy() const
+  strategy_name_option() const
+  {
+    return _strategy_name;
+  }
+  inline void const *
+  strategy_option() const
   {
     return _strategy;
   }
@@ -274,7 +279,8 @@ class RemapRegex
   int _dns_timeout         = -1;
 
   bool        _has_strategy = false;
-  std::string _strategy     = {};
+  std::string _strategy_name = {};
+  void const *_strategy = nullptr;
 
   Override *_first_override = nullptr;
   int       _sub_pos[MAX_SUBS];
@@ -323,8 +329,15 @@ RemapRegex::initialize(const std::string &reg, const std::string &sub, const std
     } else if (opt.compare(start, 23, "lowercase_substitutions") == 0) {
       _lowercase_substitutions = true;
     } else if (opt.compare(start, 8, "strategy") == 0) {
-      _has_strategy = true;
-      _strategy     = opt_val;
+      _has_strategy  = true;
+      _strategy_name = opt_val;
+      if (!_strategy_name.empty() && "null" != _strategy_name) {
+        _strategy = TSHttpInitNextHopNamedStrategyGet(_strategy_name.c_str());
+        if (nullptr == _strategy) {
+          TSError("[%s] Unable to resolve strategy: '%s'", PLUGIN_NAME, opt_val.c_str());
+          _has_strategy = false; // disable the strategy action
+        }
+      }
     } else if (opt_val.size() <= 0) {
       // All other options have a required value
       TSError("[%s] Malformed options: %s", PLUGIN_NAME, opt.c_str());
@@ -987,20 +1000,14 @@ TSRemapDoRemap(void *ih, TSHttpTxn txnp, TSRemapRequestInfo *rri)
         Dbg(dbg_ctl, "Setting DNS timeout to %d", re->dns_timeout_option());
         TSHttpTxnDNSTimeoutSet(txnp, re->dns_timeout_option());
       }
-      if (re->has_strategy()) {
-        auto const &strat = re->strategy();
-        if (strat.empty() || "null" == strat) {
+      if (re->has_strategy_option()) {
+        auto const strat = re->strategy_option();
+        if (nullptr == strat) {
           Dbg(dbg_ctl, "Clearing strategy (use parent.config)");
-          TSHttpTxnNextHopStrategySet(txnp, nullptr);
         } else {
-          void const *const stratptr = TSHttpTxnNextHopNamedStrategyGet(txnp, strat.c_str());
-          if (nullptr == stratptr) {
-            Dbg(dbg_ctl, "No strategy found with name '%s'", strat.c_str());
-          } else {
-            Dbg(dbg_ctl, "Setting strategy to %s", strat.c_str());
-            TSHttpTxnNextHopStrategySet(txnp, stratptr);
-          }
+          Dbg(dbg_ctl, "Setting strategy to %s", re->strategy_name_option().c_str());
         }
+        TSHttpTxnNextHopStrategySet(txnp, strat);
       }
       bool lowercase_substitutions = false;
       if (re->lowercase_substitutions_option() == true) {

src/api/InkAPI.cc

@@ -5044,6 +5044,24 @@ TSHttpTxnNextHopNamedStrategyGet(TSHttpTxn txnp, const char *name)
   return static_cast<void const *>(strat);
 }
 
+void const *
+TSHttpInitNextHopNamedStrategyGet(const char *name)
+{
+  auto const bt = BUILD_TABLE_INFO::instance;
+
+  sdk_assert(sdk_sanity_check_null_ptr((void *)bt) == TS_SUCCESS);
+  sdk_assert(sdk_sanity_check_null_ptr((void *)bt->rewrite) == TS_SUCCESS);
+  sdk_assert(sdk_sanity_check_null_ptr((void *)bt->rewrite->strategyFactory) == TS_SUCCESS);
+
+  // HttpSM has a reference count handle to UrlRewrite which has a
+  // pointer to NextHopStrategyFactory
+  NextHopSelectionStrategy const *const strat = bt->rewrite->strategyFactory->strategyInstance(name);
+
+  fprintf(stderr, "strategy: %s, ptr: %p\n", name, (void *)strat);
+
+  return static_cast<void const *>(strat);
+}
+
 TSReturnCode
 TSHttpTxnParentProxyGet(TSHttpTxn txnp, const char **hostname, int *port)
 {

src/proxy/http/remap/RemapConfig.cc

@@ -90,15 +90,18 @@ clear_xstr_array(char *v[], size_t vsize)
 }
 
 BUILD_TABLE_INFO::BUILD_TABLE_INFO()
-
 {
   memset(this->paramv, 0, sizeof(this->paramv));
   memset(this->argv, 0, sizeof(this->argv));
+  ink_assert(nullptr == BUILD_TABLE_INFO::instance);
+  BUILD_TABLE_INFO::instance = this;
 }
 
 BUILD_TABLE_INFO::~BUILD_TABLE_INFO()
 {
   this->reset();
+  ink_assert(nullptr != BUILD_TABLE_INFO::instance);
+  BUILD_TABLE_INFO::instance = nullptr;
 }
 
 void