Line data    Source code

       1             : #include "source/common/config/metadata.h"
       2             : 
       3             : #include "envoy/config/core/v3/base.pb.h"
       4             : #include "envoy/type/metadata/v3/metadata.pb.h"
       5             : 
       6             : #include "source/common/protobuf/utility.h"
       7             : 
       8             : namespace Envoy {
       9             : namespace Config {
      10             : 
      11             : SINGLETON_MANAGER_REGISTRATION(const_metadata_shared_pool);
      12             : 
      13             : MetadataKey::MetadataKey(const envoy::type::metadata::v3::MetadataKey& metadata_key)
      14           0 :     : key_(metadata_key.key()) {
      15           0 :   for (const auto& seg : metadata_key.path()) {
      16           0 :     path_.push_back(seg.key());
      17           0 :   }
      18           0 : }
      19             : 
      20             : const ProtobufWkt::Value& Metadata::metadataValue(const envoy::config::core::v3::Metadata* metadata,
      21           0 :                                                   const MetadataKey& metadata_key) {
      22           0 :   return metadataValue(metadata, metadata_key.key_, metadata_key.path_);
      23           0 : }
      24             : 
      25             : const ProtobufWkt::Value& Metadata::metadataValue(const envoy::config::core::v3::Metadata* metadata,
      26             :                                                   const std::string& filter,
      27      180441 :                                                   const std::vector<std::string>& path) {
      28      180441 :   if (!metadata) {
      29      180397 :     return ProtobufWkt::Value::default_instance();
      30      180397 :   }
      31          44 :   const auto filter_it = metadata->filter_metadata().find(filter);
      32          44 :   if (filter_it == metadata->filter_metadata().end()) {
      33          31 :     return ProtobufWkt::Value::default_instance();
      34          31 :   }
      35          13 :   const ProtobufWkt::Struct* data_struct = &(filter_it->second);
      36          13 :   const ProtobufWkt::Value* val = nullptr;
      37             :   // go through path to select sub entries
      38          13 :   for (const auto& p : path) {
      39          13 :     if (nullptr == data_struct) { // sub entry not found
      40           0 :       return ProtobufWkt::Value::default_instance();
      41           0 :     }
      42          13 :     const auto entry_it = data_struct->fields().find(p);
      43          13 :     if (entry_it == data_struct->fields().end()) {
      44           4 :       return ProtobufWkt::Value::default_instance();
      45           4 :     }
      46           9 :     val = &(entry_it->second);
      47           9 :     if (val->has_struct_value()) {
      48           0 :       data_struct = &(val->struct_value());
      49           9 :     } else {
      50           9 :       data_struct = nullptr;
      51           9 :     }
      52           9 :   }
      53           9 :   if (nullptr == val) {
      54           0 :     return ProtobufWkt::Value::default_instance();
      55           0 :   }
      56           9 :   return *val;
      57           9 : }
      58             : 
      59             : const ProtobufWkt::Value& Metadata::metadataValue(const envoy::config::core::v3::Metadata* metadata,
      60             :                                                   const std::string& filter,
      61      180397 :                                                   const std::string& key) {
      62      180397 :   const std::vector<std::string> path{key};
      63      180397 :   return metadataValue(metadata, filter, path);
      64      180397 : }
      65             : 
      66             : ProtobufWkt::Value& Metadata::mutableMetadataValue(envoy::config::core::v3::Metadata& metadata,
      67             :                                                    const std::string& filter,
      68           0 :                                                    const std::string& key) {
      69           0 :   return (*(*metadata.mutable_filter_metadata())[filter].mutable_fields())[key];
      70           0 : }
      71             : 
      72             : bool Metadata::metadataLabelMatch(const LabelSet& label_set,
      73             :                                   const envoy::config::core::v3::Metadata* host_metadata,
      74           0 :                                   const std::string& filter_key, bool list_as_any) {
      75           0 :   if (!host_metadata) {
      76           0 :     return label_set.empty();
      77           0 :   }
      78           0 :   const auto filter_it = host_metadata->filter_metadata().find(filter_key);
      79           0 :   if (filter_it == host_metadata->filter_metadata().end()) {
      80           0 :     return label_set.empty();
      81           0 :   }
      82           0 :   const ProtobufWkt::Struct& data_struct = filter_it->second;
      83           0 :   const auto& fields = data_struct.fields();
      84           0 :   for (const auto& kv : label_set) {
      85           0 :     const auto entry_it = fields.find(kv.first);
      86           0 :     if (entry_it == fields.end()) {
      87           0 :       return false;
      88           0 :     }
      89             : 
      90           0 :     if (list_as_any && entry_it->second.kind_case() == ProtobufWkt::Value::kListValue) {
      91           0 :       bool any_match = false;
      92           0 :       for (const auto& v : entry_it->second.list_value().values()) {
      93           0 :         if (ValueUtil::equal(v, kv.second)) {
      94           0 :           any_match = true;
      95           0 :           break;
      96           0 :         }
      97           0 :       }
      98           0 :       if (!any_match) {
      99           0 :         return false;
     100           0 :       }
     101           0 :     } else if (!ValueUtil::equal(entry_it->second, kv.second)) {
     102           0 :       return false;
     103           0 :     }
     104           0 :   }
     105           0 :   return true;
     106           0 : }
     107             : 
     108             : ConstMetadataSharedPoolSharedPtr
     109         159 : Metadata::getConstMetadataSharedPool(Singleton::Manager& manager, Event::Dispatcher& dispatcher) {
     110         159 :   return manager.getTyped<SharedPool::ObjectSharedPool<const envoy::config::core::v3::Metadata,
     111         159 :                                                        MessageUtil, MessageUtil>>(
     112         159 :       SINGLETON_MANAGER_REGISTERED_NAME(const_metadata_shared_pool), [&dispatcher] {
     113          98 :         return std::make_shared<SharedPool::ObjectSharedPool<
     114          98 :             const envoy::config::core::v3::Metadata, MessageUtil, MessageUtil>>(dispatcher);
     115          98 :       });
     116         159 : }
     117             : 
     118             : } // namespace Config
     119             : } // namespace Envoy