grpc 1.50.0-x86_64-linux → 1.51.0-x86_64-linux

data/src/core/ext/xds/xds_http_fault_filter.cc

@@ -20,14 +20,13 @@
 
 #include <stdint.h>
 
-#include <map>
 #include <string>
 #include <utility>
 
-#include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "absl/types/variant.h"
 #include "envoy/extensions/filters/common/fault/v3/fault.upb.h"
 #include "envoy/extensions/filters/http/fault/v3/fault.upb.h"
 #include "envoy/extensions/filters/http/fault/v3/fault.upbdefs.h"
@@ -38,19 +37,18 @@
 #include <grpc/status.h>
 
 #include "src/core/ext/filters/fault_injection/fault_injection_filter.h"
+#include "src/core/ext/filters/fault_injection/fault_injection_service_config_parser.h"
 #include "src/core/ext/xds/xds_common_types.h"
 #include "src/core/ext/xds/xds_http_filters.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/json/json.h"
 #include "src/core/lib/transport/status_conversion.h"
 
 namespace grpc_core {
 
-const char* kXdsHttpFaultFilterConfigName =
-    "envoy.extensions.filters.http.fault.v3.HTTPFault";
-
 namespace {
 
 uint32_t GetDenominator(const envoy_type_v3_FractionalPercent* fraction) {
@@ -72,13 +70,36 @@ uint32_t GetDenominator(const envoy_type_v3_FractionalPercent* fraction) {
   return 100;
 }
 
-absl::StatusOr<Json> ParseHttpFaultIntoJson(
-    upb_StringView serialized_http_fault, upb_Arena* arena) {
+}  // namespace
+
+absl::string_view XdsHttpFaultFilter::ConfigProtoName() const {
+  return "envoy.extensions.filters.http.fault.v3.HTTPFault";
+}
+
+absl::string_view XdsHttpFaultFilter::OverrideConfigProtoName() const {
+  return "";
+}
+
+void XdsHttpFaultFilter::PopulateSymtab(upb_DefPool* symtab) const {
+  envoy_extensions_filters_http_fault_v3_HTTPFault_getmsgdef(symtab);
+}
+
+absl::optional<XdsHttpFilterImpl::FilterConfig>
+XdsHttpFaultFilter::GenerateFilterConfig(XdsExtension extension,
+                                         upb_Arena* arena,
+                                         ValidationErrors* errors) const {
+  absl::string_view* serialized_filter_config =
+      absl::get_if<absl::string_view>(&extension.value);
+  if (serialized_filter_config == nullptr) {
+    errors->AddError("could not parse fault injection filter config");
+    return absl::nullopt;
+  }
   auto* http_fault = envoy_extensions_filters_http_fault_v3_HTTPFault_parse(
-      serialized_http_fault.data, serialized_http_fault.size, arena);
+      serialized_filter_config->data(), serialized_filter_config->size(),
+      arena);
   if (http_fault == nullptr) {
-    return absl::InvalidArgumentError(
-        "could not parse fault injection filter config");
+    errors->AddError("could not parse fault injection filter config");
+    return absl::nullopt;
   }
   // NOTE(lidiz): Here, we are manually translating the upb messages into the
   // JSON form of the filter config as part of method config, which will be
@@ -93,6 +114,7 @@ absl::StatusOr<Json> ParseHttpFaultIntoJson(
   const auto* fault_abort =
       envoy_extensions_filters_http_fault_v3_HTTPFault_abort(http_fault);
   if (fault_abort != nullptr) {
+    ValidationErrors::ScopedField field(errors, ".abort");
     grpc_status_code abort_grpc_status_code = GRPC_STATUS_OK;
     // Try if gRPC status code is set first
     int abort_grpc_status_code_raw =
@@ -101,8 +123,9 @@ absl::StatusOr<Json> ParseHttpFaultIntoJson(
     if (abort_grpc_status_code_raw != 0) {
       if (!grpc_status_code_from_int(abort_grpc_status_code_raw,
                                      &abort_grpc_status_code)) {
-        return absl::InvalidArgumentError(absl::StrCat(
-            "invalid gRPC status code: ", abort_grpc_status_code_raw));
+        ValidationErrors::ScopedField field(errors, ".grpc_status");
+        errors->AddError(absl::StrCat("invalid gRPC status code: ",
+                                      abort_grpc_status_code_raw));
       }
     } else {
       // if gRPC status code is empty, check http status
@@ -129,22 +152,26 @@ absl::StatusOr<Json> ParseHttpFaultIntoJson(
     auto* percent =
         envoy_extensions_filters_http_fault_v3_FaultAbort_percentage(
             fault_abort);
-    fault_injection_policy_json["abortPercentageNumerator"] =
-        Json(envoy_type_v3_FractionalPercent_numerator(percent));
-    fault_injection_policy_json["abortPercentageDenominator"] =
-        Json(GetDenominator(percent));
+    if (percent != nullptr) {
+      fault_injection_policy_json["abortPercentageNumerator"] =
+          envoy_type_v3_FractionalPercent_numerator(percent);
+      fault_injection_policy_json["abortPercentageDenominator"] =
+          GetDenominator(percent);
+    }
   }
   // Section 2: Parse the delay injection config
   const auto* fault_delay =
       envoy_extensions_filters_http_fault_v3_HTTPFault_delay(http_fault);
   if (fault_delay != nullptr) {
+    ValidationErrors::ScopedField field(errors, ".delay");
     // Parse the delay duration
     const auto* delay_duration =
         envoy_extensions_filters_common_fault_v3_FaultDelay_fixed_delay(
             fault_delay);
     if (delay_duration != nullptr) {
-      fault_injection_policy_json["delay"] =
-          ParseDuration(delay_duration).ToJsonString();
+      ValidationErrors::ScopedField field(errors, ".fixed_delay");
+      Duration duration = ParseDuration(delay_duration, errors);
+      fault_injection_policy_json["delay"] = duration.ToJsonString();
     }
     // Set the headers if we enabled header delay injection control
     if (envoy_extensions_filters_common_fault_v3_FaultDelay_has_header_delay(
@@ -158,10 +185,12 @@ absl::StatusOr<Json> ParseHttpFaultIntoJson(
     auto* percent =
         envoy_extensions_filters_common_fault_v3_FaultDelay_percentage(
             fault_delay);
-    fault_injection_policy_json["delayPercentageNumerator"] =
-        Json(envoy_type_v3_FractionalPercent_numerator(percent));
-    fault_injection_policy_json["delayPercentageDenominator"] =
-        Json(GetDenominator(percent));
+    if (percent != nullptr) {
+      fault_injection_policy_json["delayPercentageNumerator"] =
+          envoy_type_v3_FractionalPercent_numerator(percent);
+      fault_injection_policy_json["delayPercentageDenominator"] =
+          GetDenominator(percent);
+    }
   }
   // Section 3: Parse the maximum active faults
   const auto* max_fault_wrapper =
@@ -171,32 +200,16 @@ absl::StatusOr<Json> ParseHttpFaultIntoJson(
     fault_injection_policy_json["maxFaults"] =
         google_protobuf_UInt32Value_value(max_fault_wrapper);
   }
-  return fault_injection_policy_json;
-}
-
-}  // namespace
-
-void XdsHttpFaultFilter::PopulateSymtab(upb_DefPool* symtab) const {
-  envoy_extensions_filters_http_fault_v3_HTTPFault_getmsgdef(symtab);
-}
-
-absl::StatusOr<XdsHttpFilterImpl::FilterConfig>
-XdsHttpFaultFilter::GenerateFilterConfig(
-    upb_StringView serialized_filter_config, upb_Arena* arena) const {
-  absl::StatusOr<Json> parse_result =
-      ParseHttpFaultIntoJson(serialized_filter_config, arena);
-  if (!parse_result.ok()) {
-    return parse_result.status();
-  }
-  return FilterConfig{kXdsHttpFaultFilterConfigName, std::move(*parse_result)};
+  return FilterConfig{ConfigProtoName(),
+                      std::move(fault_injection_policy_json)};
 }
 
-absl::StatusOr<XdsHttpFilterImpl::FilterConfig>
+absl::optional<XdsHttpFilterImpl::FilterConfig>
 XdsHttpFaultFilter::GenerateFilterConfigOverride(
-    upb_StringView serialized_filter_config, upb_Arena* arena) const {
+    XdsExtension extension, upb_Arena* arena, ValidationErrors* errors) const {
   // HTTPFault filter has the same message type in HTTP connection manager's
   // filter config and in overriding filter config field.
-  return GenerateFilterConfig(serialized_filter_config, arena);
+  return GenerateFilterConfig(std::move(extension), arena, errors);
 }
 
 const grpc_channel_filter* XdsHttpFaultFilter::channel_filter() const {

data/src/core/ext/xds/xds_http_fault_filter.h

@@ -20,47 +20,39 @@
 #include <grpc/support/port_platform.h>
 
 #include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
 #include "upb/arena.h"
 #include "upb/def.h"
-#include "upb/upb.h"
 
+#include "src/core/ext/xds/xds_common_types.h"
 #include "src/core/ext/xds/xds_http_filters.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
+#include "src/core/lib/gprpp/validation_errors.h"
 
 namespace grpc_core {
 
-extern const char* kXdsHttpFaultFilterConfigName;
-
 class XdsHttpFaultFilter : public XdsHttpFilterImpl {
  public:
-  // Overrides the PopulateSymtab method
+  absl::string_view ConfigProtoName() const override;
+  absl::string_view OverrideConfigProtoName() const override;
   void PopulateSymtab(upb_DefPool* symtab) const override;
-
-  // Overrides the GenerateFilterConfig method
-  absl::StatusOr<FilterConfig> GenerateFilterConfig(
-      upb_StringView serialized_filter_config, upb_Arena* arena) const override;
-
-  // Overrides the GenerateFilterConfigOverride method
-  absl::StatusOr<FilterConfig> GenerateFilterConfigOverride(
-      upb_StringView serialized_filter_config, upb_Arena* arena) const override;
-
-  // Overrides the channel_filter method
+  absl::optional<FilterConfig> GenerateFilterConfig(
+      XdsExtension extension, upb_Arena* arena,
+      ValidationErrors* errors) const override;
+  absl::optional<FilterConfig> GenerateFilterConfigOverride(
+      XdsExtension extension, upb_Arena* arena,
+      ValidationErrors* errors) const override;
   const grpc_channel_filter* channel_filter() const override;
-
-  // Overrides the ModifyChannelArgs method
   ChannelArgs ModifyChannelArgs(const ChannelArgs& args) const override;
-
-  // Overrides the GenerateServiceConfig method
   absl::StatusOr<ServiceConfigJsonEntry> GenerateServiceConfig(
       const FilterConfig& hcm_filter_config,
       const FilterConfig* filter_config_override) const override;
-
   bool IsSupportedOnClients() const override { return true; }
-
   bool IsSupportedOnServers() const override { return false; }
 };
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_XDS_XDS_HTTP_FAULT_FILTER_H */
+#endif  // GRPC_CORE_EXT_XDS_XDS_HTTP_FAULT_FILTER_H

data/src/core/ext/xds/xds_http_filters.cc

@@ -23,107 +23,94 @@
 #include <utility>
 #include <vector>
 
-#include "absl/memory/memory.h"
-#include "absl/status/status.h"
+#include "absl/types/variant.h"
 #include "envoy/extensions/filters/http/router/v3/router.upb.h"
 #include "envoy/extensions/filters/http/router/v3/router.upbdefs.h"
 
+#include <grpc/support/log.h>
+
 #include "src/core/ext/xds/xds_http_fault_filter.h"
 #include "src/core/ext/xds/xds_http_rbac_filter.h"
 
 namespace grpc_core {
 
-const char* kXdsHttpRouterFilterConfigName =
-    "envoy.extensions.filters.http.router.v3.Router";
+//
+// XdsHttpRouterFilter
+//
 
-namespace {
+absl::string_view XdsHttpRouterFilter::ConfigProtoName() const {
+  return "envoy.extensions.filters.http.router.v3.Router";
+}
 
-class XdsHttpRouterFilter : public XdsHttpFilterImpl {
- public:
-  void PopulateSymtab(upb_DefPool* symtab) const override {
-    envoy_extensions_filters_http_router_v3_Router_getmsgdef(symtab);
-  }
+absl::string_view XdsHttpRouterFilter::OverrideConfigProtoName() const {
+  return "";
+}
 
-  absl::StatusOr<FilterConfig> GenerateFilterConfig(
-      upb_StringView serialized_filter_config,
-      upb_Arena* arena) const override {
-    if (envoy_extensions_filters_http_router_v3_Router_parse(
-            serialized_filter_config.data, serialized_filter_config.size,
-            arena) == nullptr) {
-      return absl::InvalidArgumentError("could not parse router filter config");
-    }
-    return FilterConfig{kXdsHttpRouterFilterConfigName, Json()};
-  }
+void XdsHttpRouterFilter::PopulateSymtab(upb_DefPool* symtab) const {
+  envoy_extensions_filters_http_router_v3_Router_getmsgdef(symtab);
+}
 
-  absl::StatusOr<FilterConfig> GenerateFilterConfigOverride(
-      upb_StringView /*serialized_filter_config*/,
-      upb_Arena* /*arena*/) const override {
-    return absl::InvalidArgumentError(
-        "router filter does not support config override");
+absl::optional<XdsHttpFilterImpl::FilterConfig>
+XdsHttpRouterFilter::GenerateFilterConfig(XdsExtension extension,
+                                          upb_Arena* arena,
+                                          ValidationErrors* errors) const {
+  absl::string_view* serialized_filter_config =
+      absl::get_if<absl::string_view>(&extension.value);
+  if (serialized_filter_config == nullptr) {
+    errors->AddError("could not parse router filter config");
+    return absl::nullopt;
   }
-
-  const grpc_channel_filter* channel_filter() const override { return nullptr; }
-
-  // No-op.  This will never be called, since channel_filter() returns null.
-  absl::StatusOr<ServiceConfigJsonEntry> GenerateServiceConfig(
-      const FilterConfig& /*hcm_filter_config*/,
-      const FilterConfig* /*filter_config_override*/) const override {
-    return absl::UnimplementedError("router filter should never be called");
+  if (envoy_extensions_filters_http_router_v3_Router_parse(
+          serialized_filter_config->data(), serialized_filter_config->size(),
+          arena) == nullptr) {
+    errors->AddError("could not parse router filter config");
+    return absl::nullopt;
   }
+  return FilterConfig{ConfigProtoName(), Json()};
+}
 
-  bool IsSupportedOnClients() const override { return true; }
-
-  bool IsSupportedOnServers() const override { return true; }
-
-  bool IsTerminalFilter() const override { return true; }
-};
-
-using FilterOwnerList = std::vector<std::unique_ptr<XdsHttpFilterImpl>>;
-using FilterRegistryMap = std::map<absl::string_view, XdsHttpFilterImpl*>;
+absl::optional<XdsHttpFilterImpl::FilterConfig>
+XdsHttpRouterFilter::GenerateFilterConfigOverride(
+    XdsExtension /*extension*/, upb_Arena* /*arena*/,
+    ValidationErrors* errors) const {
+  errors->AddError("router filter does not support config override");
+  return absl::nullopt;
+}
 
-FilterOwnerList* g_filters = nullptr;
-FilterRegistryMap* g_filter_registry = nullptr;
+//
+// XdsHttpFilterRegistry
+//
 
-}  // namespace
+XdsHttpFilterRegistry::XdsHttpFilterRegistry(bool register_builtins) {
+  if (register_builtins) {
+    RegisterFilter(std::make_unique<XdsHttpRouterFilter>());
+    RegisterFilter(std::make_unique<XdsHttpFaultFilter>());
+    RegisterFilter(std::make_unique<XdsHttpRbacFilter>());
+  }
+}
 
 void XdsHttpFilterRegistry::RegisterFilter(
-    std::unique_ptr<XdsHttpFilterImpl> filter,
-    const std::set<absl::string_view>& config_proto_type_names) {
-  for (auto config_proto_type_name : config_proto_type_names) {
-    (*g_filter_registry)[config_proto_type_name] = filter.get();
+    std::unique_ptr<XdsHttpFilterImpl> filter) {
+  GPR_ASSERT(
+      registry_map_.emplace(filter->ConfigProtoName(), filter.get()).second);
+  auto override_proto_name = filter->OverrideConfigProtoName();
+  if (!override_proto_name.empty()) {
+    GPR_ASSERT(registry_map_.emplace(override_proto_name, filter.get()).second);
   }
-  g_filters->push_back(std::move(filter));
+  owning_list_.push_back(std::move(filter));
 }
 
 const XdsHttpFilterImpl* XdsHttpFilterRegistry::GetFilterForType(
-    absl::string_view proto_type_name) {
-  auto it = g_filter_registry->find(proto_type_name);
-  if (it == g_filter_registry->end()) return nullptr;
+    absl::string_view proto_type_name) const {
+  auto it = registry_map_.find(proto_type_name);
+  if (it == registry_map_.end()) return nullptr;
   return it->second;
 }
 
-void XdsHttpFilterRegistry::PopulateSymtab(upb_DefPool* symtab) {
-  for (const auto& filter : *g_filters) {
+void XdsHttpFilterRegistry::PopulateSymtab(upb_DefPool* symtab) const {
+  for (const auto& filter : owning_list_) {
     filter->PopulateSymtab(symtab);
   }
 }
 
-void XdsHttpFilterRegistry::Init() {
-  g_filters = new FilterOwnerList;
-  g_filter_registry = new FilterRegistryMap;
-  RegisterFilter(absl::make_unique<XdsHttpRouterFilter>(),
-                 {kXdsHttpRouterFilterConfigName});
-  RegisterFilter(absl::make_unique<XdsHttpFaultFilter>(),
-                 {kXdsHttpFaultFilterConfigName});
-  RegisterFilter(absl::make_unique<XdsHttpRbacFilter>(),
-                 {kXdsHttpRbacFilterConfigName});
-  RegisterFilter(absl::make_unique<XdsHttpRbacFilter>(),
-                 {kXdsHttpRbacFilterConfigOverrideName});
-}
-
-void XdsHttpFilterRegistry::Shutdown() {
-  delete g_filter_registry;
-  delete g_filters;
-}
-
 }  // namespace grpc_core

data/src/core/ext/xds/xds_http_filters.h

@@ -19,25 +19,28 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <map>
 #include <memory>
-#include <set>
 #include <string>
+#include <utility>
+#include <vector>
 
+#include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
 #include "upb/arena.h"
 #include "upb/def.h"
-#include "upb/upb.h"
 
+#include "src/core/ext/xds/xds_common_types.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
+#include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/json/json.h"
 
 namespace grpc_core {
 
-extern const char* kXdsHttpRouterFilterConfigName;
-
 class XdsHttpFilterImpl {
  public:
   struct FilterConfig {
@@ -69,25 +72,33 @@ class XdsHttpFilterImpl {
 
   virtual ~XdsHttpFilterImpl() = default;
 
+  // Returns the top-level filter config proto message name.
+  virtual absl::string_view ConfigProtoName() const = 0;
+
+  // Returns the override filter config proto message name.
+  // If empty, no override type is supported.
+  virtual absl::string_view OverrideConfigProtoName() const = 0;
+
   // Loads the proto message into the upb symtab.
   virtual void PopulateSymtab(upb_DefPool* symtab) const = 0;
 
   // Generates a Config from the xDS filter config proto.
   // Used for the top-level config in the HCM HTTP filter list.
-  virtual absl::StatusOr<FilterConfig> GenerateFilterConfig(
-      upb_StringView serialized_filter_config, upb_Arena* arena) const = 0;
+  virtual absl::optional<FilterConfig> GenerateFilterConfig(
+      XdsExtension extension, upb_Arena* arena,
+      ValidationErrors* errors) const = 0;
 
   // Generates a Config from the xDS filter config proto.
   // Used for the typed_per_filter_config override in VirtualHost and Route.
-  virtual absl::StatusOr<FilterConfig> GenerateFilterConfigOverride(
-      upb_StringView serialized_filter_config, upb_Arena* arena) const = 0;
+  virtual absl::optional<FilterConfig> GenerateFilterConfigOverride(
+      XdsExtension extension, upb_Arena* arena,
+      ValidationErrors* errors) const = 0;
 
   // C-core channel filter implementation.
   virtual const grpc_channel_filter* channel_filter() const = 0;
 
   // Modifies channel args that may affect service config parsing (not
   // visible to the channel as a whole).
-  // Takes ownership of args.  Caller takes ownership of return value.
   virtual ChannelArgs ModifyChannelArgs(const ChannelArgs& args) const {
     return args;
   }
@@ -112,22 +123,59 @@ class XdsHttpFilterImpl {
   virtual bool IsTerminalFilter() const { return false; }
 };
 
+class XdsHttpRouterFilter : public XdsHttpFilterImpl {
+ public:
+  absl::string_view ConfigProtoName() const override;
+  absl::string_view OverrideConfigProtoName() const override;
+  void PopulateSymtab(upb_DefPool* symtab) const override;
+  absl::optional<FilterConfig> GenerateFilterConfig(
+      XdsExtension extension, upb_Arena* arena,
+      ValidationErrors* errors) const override;
+  absl::optional<FilterConfig> GenerateFilterConfigOverride(
+      XdsExtension extension, upb_Arena* arena,
+      ValidationErrors* errors) const override;
+  const grpc_channel_filter* channel_filter() const override { return nullptr; }
+  absl::StatusOr<ServiceConfigJsonEntry> GenerateServiceConfig(
+      const FilterConfig& /*hcm_filter_config*/,
+      const FilterConfig* /*filter_config_override*/) const override {
+    // This will never be called, since channel_filter() returns null.
+    return absl::UnimplementedError("router filter should never be called");
+  }
+  bool IsSupportedOnClients() const override { return true; }
+  bool IsSupportedOnServers() const override { return true; }
+  bool IsTerminalFilter() const override { return true; }
+};
+
 class XdsHttpFilterRegistry {
  public:
-  static void RegisterFilter(
-      std::unique_ptr<XdsHttpFilterImpl> filter,
-      const std::set<absl::string_view>& config_proto_type_names);
+  explicit XdsHttpFilterRegistry(bool register_builtins = true);
+
+  // Not copyable.
+  XdsHttpFilterRegistry(const XdsHttpFilterRegistry&) = delete;
+  XdsHttpFilterRegistry& operator=(const XdsHttpFilterRegistry&) = delete;
+
+  // Movable.
+  XdsHttpFilterRegistry(XdsHttpFilterRegistry&& other) noexcept
+      : owning_list_(std::move(other.owning_list_)),
+        registry_map_(std::move(other.registry_map_)) {}
+  XdsHttpFilterRegistry& operator=(XdsHttpFilterRegistry&& other) noexcept {
+    owning_list_ = std::move(other.owning_list_);
+    registry_map_ = std::move(other.registry_map_);
+    return *this;
+  }
+
+  void RegisterFilter(std::unique_ptr<XdsHttpFilterImpl> filter);
 
-  static const XdsHttpFilterImpl* GetFilterForType(
-      absl::string_view proto_type_name);
+  const XdsHttpFilterImpl* GetFilterForType(
+      absl::string_view proto_type_name) const;
 
-  static void PopulateSymtab(upb_DefPool* symtab);
+  void PopulateSymtab(upb_DefPool* symtab) const;
 
-  // Global init and shutdown.
-  static void Init();
-  static void Shutdown();
+ private:
+  std::vector<std::unique_ptr<XdsHttpFilterImpl>> owning_list_;
+  std::map<absl::string_view, XdsHttpFilterImpl*> registry_map_;
 };
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_XDS_XDS_HTTP_FILTERS_H */
+#endif  // GRPC_CORE_EXT_XDS_XDS_HTTP_FILTERS_H