void countDeprecatedFeatureUseInternal(const RuntimeStats& stats) {

  stats.deprecated_feature_use_.inc();

  stats.deprecated_feature_seen_since_process_start_.inc();

}

void refreshReloadableFlags(const Snapshot::EntryMap& flag_map) {

  for (const auto& it : flag_map) {

    if (it.second.bool_value_.has_value() && isRuntimeFeature(it.first)) {

      maybeSetRuntimeGuard(it.first, it.second.bool_value_.value());

    }

  }

#ifdef ENVOY_ENABLE_QUIC

  absl::flat_hash_map<std::string, bool> quiche_flags_override;

  for (const auto& it : flag_map) {

    if (absl::StartsWith(it.first, quiche::EnvoyQuicheReloadableFlagPrefix) &&

        it.second.bool_value_.has_value()) {

      quiche_flags_override[it.first.substr(quiche::EnvoyFeaturePrefix.length())] =

          it.second.bool_value_.value();

    }

  }

  quiche::FlagRegistry::getInstance().updateReloadableFlags(quiche_flags_override);

  SetQuicheFlag(quic_always_support_server_preferred_address,

                Runtime::runtimeFeatureEnabled(

                    "envoy.reloadable_features.quic_send_server_preferred_address_to_all_clients"));

#endif

  for (const auto& it : flag_map) {

    if (it.second.uint_value_.has_value()) {

      maybeSetDeprecatedInts(it.first, it.second.uint_value_.value());

    }

  }

  markRuntimeInitialized();

}

bool SnapshotImpl::deprecatedFeatureEnabled(absl::string_view key, bool default_value) const {

  if (!getBoolean(key,

                  getBoolean("envoy.features.enable_all_deprecated_features", default_value))) {

    return false;

  }

  countDeprecatedFeatureUseInternal(stats_);

  return true;

}

bool SnapshotImpl::runtimeFeatureEnabled(absl::string_view key) const {

  return getBoolean(key, Runtime::runtimeFeatureEnabled(key));

}

                                  uint64_t random_value, uint64_t num_buckets) const {

  return random_value % num_buckets < std::min(getInteger(key, default_value), num_buckets);

}

bool SnapshotImpl::featureEnabled(absl::string_view key, uint64_t default_value) const {

  uint64_t cutoff = std::min(getInteger(key, default_value), static_cast<uint64_t>(100));

  if (cutoff == 0) {

    return false;

  } else if (cutoff == 100) {

    return true;

  } else {

    return generator_.random() % 100 < cutoff;

  }

}

                                  uint64_t random_value) const {

  return featureEnabled(key, default_value, random_value, 100);

}

Snapshot::ConstStringOptRef SnapshotImpl::get(absl::string_view key) const {

  ASSERT(!isRuntimeFeature(key)); // Make sure runtime guarding is only used for getBoolean

  auto entry = key.empty() ? values_.end() : values_.find(key);

  if (entry == values_.end()) {

    return absl::nullopt;

  } else {

    return entry->second.raw_string_value_;

  }

}

                                  const envoy::type::v3::FractionalPercent& default_value) const {

  return featureEnabled(key, default_value, generator_.random());

}

                                  uint64_t random_value) const {

  const auto& entry = key.empty() ? values_.end() : values_.find(key);

  envoy::type::v3::FractionalPercent percent;

  if (entry != values_.end() && entry->second.fractional_percent_value_.has_value()) {

    percent = entry->second.fractional_percent_value_.value();

  } else if (entry != values_.end() && entry->second.uint_value_.has_value()) {

    if (entry->second.uint_value_.value() > 100) {

      return true;

    }

    percent.set_numerator(entry->second.uint_value_.value());

    percent.set_denominator(envoy::type::v3::FractionalPercent::HUNDRED);

  } else {

    percent = default_value;

  }

  uint64_t denominator_value =

      ProtobufPercentHelper::fractionalPercentDenominatorToInt(percent.denominator());

  if (percent.numerator() > denominator_value) {

    ENVOY_LOG(debug,

              "WARNING runtime key '{}': numerator ({}) > denominator ({}), condition always "

              "evaluates to true",

              key, percent.numerator(), denominator_value);

    return true;

  }

  return ProtobufPercentHelper::evaluateFractionalPercent(percent, random_value);

}

uint64_t SnapshotImpl::getInteger(absl::string_view key, uint64_t default_value) const {

  ASSERT(!isRuntimeFeature(key));

  const auto& entry = key.empty() ? values_.end() : values_.find(key);

  if (entry == values_.end() || !entry->second.uint_value_) {

    return default_value;

  } else {

    return entry->second.uint_value_.value();

  }

}

double SnapshotImpl::getDouble(absl::string_view key, double default_value) const {

  ASSERT(!isRuntimeFeature(key)); // Make sure runtime guarding is only used for getBoolean

  const auto& entry = key.empty() ? values_.end() : values_.find(key);

  if (entry == values_.end() || !entry->second.double_value_) {

    return default_value;

  } else {

    return entry->second.double_value_.value();

  }

}

bool SnapshotImpl::getBoolean(absl::string_view key, bool default_value) const {

  const auto& entry = key.empty() ? values_.end() : values_.find(key);

  if (entry == values_.end() || !entry->second.bool_value_.has_value()) {

    return default_value;

  } else {

    return entry->second.bool_value_.value();

  }

}

const std::vector<Snapshot::OverrideLayerConstPtr>& SnapshotImpl::getLayers() const {

  return layers_;

}

const Snapshot::EntryMap& SnapshotImpl::values() const { return values_; }

    : layers_{std::move(layers)}, generator_{generator}, stats_{stats} {

  for (const auto& layer : layers_) {

    for (const auto& kv : layer->values()) {

      values_.erase(kv.first);

      values_.emplace(kv.first, kv.second);

    }

  }

  stats.num_keys_.set(values_.size());

}

void parseFractionValue(SnapshotImpl::Entry& entry, const Protobuf::Struct& value) {

  envoy::type::v3::FractionalPercent percent;

  static_assert(envoy::type::v3::FractionalPercent::MILLION ==

                envoy::type::v3::FractionalPercent::DenominatorType_MAX);

  percent.set_denominator(envoy::type::v3::FractionalPercent::HUNDRED);

  for (const auto& f : value.fields()) {

    if (f.first == "numerator") {

      if (f.second.has_number_value()) {

        percent.set_numerator(f.second.number_value());

      }

    } else if (f.first == "denominator" && f.second.has_string_value()) {

      if (f.second.string_value() == "HUNDRED") {

        percent.set_denominator(envoy::type::v3::FractionalPercent::HUNDRED);

      } else if (f.second.string_value() == "TEN_THOUSAND") {

        percent.set_denominator(envoy::type::v3::FractionalPercent::TEN_THOUSAND);

      } else if (f.second.string_value() == "MILLION") {

        percent.set_denominator(envoy::type::v3::FractionalPercent::MILLION);

      } else {

        return;

      }

    } else {

      return;

    }

  }

  entry.fractional_percent_value_ = percent;

}

void setNumberValue(Envoy::Runtime::Snapshot::Entry& entry, double value) {

  entry.double_value_ = value;

  if (value < std::numeric_limits<int>::max() && value == static_cast<int>(value)) {

    entry.bool_value_ = value != 0;

  }

  if (entry.double_value_ >= 0 && entry.double_value_ <= std::numeric_limits<uint64_t>::max()) {

    entry.uint_value_ = entry.double_value_;

  }

}

bool parseEntryDoubleValue(Envoy::Runtime::Snapshot::Entry& entry) {

  double converted_double;

  if (absl::SimpleAtod(entry.raw_string_value_, &converted_double)) {

    setNumberValue(entry, converted_double);

    return true;

  }

  return false;

}

                            const Protobuf::Value& value, absl::string_view raw_string) {

  values.emplace(key, SnapshotImpl::createEntry(value, raw_string));

}

                                              absl::string_view raw_string) {

  Entry entry;

  entry.raw_string_value_ = value.string_value();

  if (!raw_string.empty()) {

    entry.raw_string_value_ = raw_string;

  }

  switch (value.kind_case()) {

  case Protobuf::Value::kNumberValue:

    setNumberValue(entry, value.number_value());

    if (entry.raw_string_value_.empty()) {

      entry.raw_string_value_ = absl::StrCat(value.number_value());

    }

    break;

  case Protobuf::Value::kBoolValue:

    entry.bool_value_ = value.bool_value();

    if (entry.raw_string_value_.empty()) {

      entry.raw_string_value_ = value.bool_value() ? "true" : "false";

    }

    break;

  case Protobuf::Value::kStructValue:

    if (entry.raw_string_value_.empty()) {

      entry.raw_string_value_ = value.struct_value().DebugString();

    }

    parseFractionValue(entry, value.struct_value());

    break;

  case Protobuf::Value::kStringValue:

    parseEntryDoubleValue(entry);

    break;

  default:

    break;

  }

  return entry;

}

absl::Status AdminLayer::mergeValues(const absl::node_hash_map<std::string, std::string>& values) {

#ifdef ENVOY_ENABLE_YAML

  for (const auto& kv : values) {

    values_.erase(kv.first);

    if (!kv.second.empty()) {

      SnapshotImpl::addEntry(values_, kv.first, ValueUtil::loadFromYaml(kv.second), kv.second);

    }

  }

  stats_.admin_overrides_active_.set(values_.empty() ? 0 : 1);

  return absl::OkStatus();

}

    : OverrideLayerImpl{name} {

  creation_status = walkDirectory(path, "", 1, api);

}

                                      uint32_t depth, Api::Api& api) {

  static constexpr uint32_t MaxWalkDepth = 16;

  ENVOY_LOG(debug, "walking directory: {}", path);

  if (depth > MaxWalkDepth) {

    return absl::InvalidArgumentError(absl::StrCat("Walk recursion depth exceeded ", MaxWalkDepth));

  }

  if (api.fileSystem().illegalPath(path)) {

    return absl::InvalidArgumentError(absl::StrCat("Invalid path: ", path));

  }

  Filesystem::Directory directory(path);

  Filesystem::DirectoryIteratorImpl it = directory.begin();

  RETURN_IF_NOT_OK_REF(it.status());

  for (; it != directory.end(); ++it) {

    RETURN_IF_NOT_OK_REF(it.status());

    Filesystem::DirectoryEntry entry = *it;

    std::string full_path = path + "/" + entry.name_;

    std::string full_prefix;

    if (prefix.empty()) {

      full_prefix = entry.name_;

    } else {

      full_prefix = prefix + "." + entry.name_;

    }

    if (entry.type_ == Filesystem::FileType::Directory && entry.name_ != "." &&

        entry.name_ != "..") {

      absl::Status status = walkDirectory(full_path, full_prefix, depth + 1, api);

      RETURN_IF_NOT_OK(status);

    } else if (entry.type_ == Filesystem::FileType::Regular) {

      ENVOY_LOG(debug, "reading file: {}", full_path);

      std::string value;

      auto file_or_error = api.fileSystem().fileReadToEnd(full_path);

      RETURN_IF_NOT_OK_REF(file_or_error.status());

      const std::string text_file{file_or_error.value()};

      const auto lines = StringUtil::splitToken(text_file, "\n");

      for (const auto& line : lines) {

        if (!line.empty() && line.front() == '#') {

          continue;

        }

        if (line == lines.back()) {

          const absl::string_view trimmed = StringUtil::rtrim(line);

          value.append(trimmed.data(), trimmed.size());

        } else {

          value.append(std::string{line} + "\n");

        }

      }

      values_.erase(full_prefix);

#ifdef ENVOY_ENABLE_YAML

      SnapshotImpl::addEntry(values_, full_prefix, ValueUtil::loadFromYaml(value), value);

    }

  }

  RETURN_IF_NOT_OK_REF(it.status());

  return absl::OkStatus();

}

    : OverrideLayerImpl{name} {

  creation_status = absl::OkStatus();

  for (const auto& f : proto.fields()) {

    creation_status = walkProtoValue(f.second, f.first);

    if (!creation_status.ok()) {

      return;

    }

  }

}

absl::Status ProtoLayer::walkProtoValue(const Protobuf::Value& v, const std::string& prefix) {

  switch (v.kind_case()) {

  case Protobuf::Value::kListValue:

  case Protobuf::Value::kNullValue:

    return absl::InvalidArgumentError(absl::StrCat("Invalid runtime entry value for ", prefix));

  case Protobuf::Value::kStringValue:

    SnapshotImpl::addEntry(values_, prefix, v, "");

    break;

  case Protobuf::Value::kNumberValue:

  case Protobuf::Value::kBoolValue:

    if (hasRuntimePrefix(prefix) && !isRuntimeFeature(prefix) && !isLegacyRuntimeFeature(prefix)) {

      IS_ENVOY_BUG(absl::StrCat(

          "Using a removed guard ", prefix,

          ". In future version of Envoy this will be treated as invalid configuration"));

    }

    SnapshotImpl::addEntry(values_, prefix, v, "");

    break;

  case Protobuf::Value::kStructValue: {

    const Protobuf::Struct& s = v.struct_value();

    if (s.fields().empty() || s.fields().find("numerator") != s.fields().end() ||

        s.fields().find("denominator") != s.fields().end()) {

      SnapshotImpl::addEntry(values_, prefix, v, "");

      break;

    }

    for (const auto& f : s.fields()) {

      absl::Status status = walkProtoValue(f.second, prefix + "." + f.first);

      RETURN_IF_NOT_OK(status);

    }

    break;

  }

  }

  return absl::OkStatus();

}

    : generator_(generator), stats_(generateStats(store)), tls_(tls.allocateSlot()),

      config_(config), service_cluster_(local_info.clusterName()), api_(api),

      init_watcher_("RTDS", [this]() { onRtdsReady(); }), store_(store) {}

                   ProtobufMessage::ValidationVisitor& validation_visitor, Api::Api& api) {

  auto loader =

      std::unique_ptr<LoaderImpl>(new LoaderImpl(tls, config, local_info, store, generator, api));

  auto result = loader->initLayers(dispatcher, validation_visitor);

  RETURN_IF_NOT_OK(result);

  return loader;

}

                                    ProtobufMessage::ValidationVisitor& validation_visitor) {

  absl::Status creation_status;

  absl::node_hash_set<std::string> layer_names;

  for (const auto& layer : config_.layers()) {

    auto ret = layer_names.insert(layer.name());

    if (!ret.second) {

      return absl::InvalidArgumentError(absl::StrCat("Duplicate layer name: ", layer.name()));

    }

    switch (layer.layer_specifier_case()) {

    case envoy::config::bootstrap::v3::RuntimeLayer::LayerSpecifierCase::kStaticLayer:

      break;

    case envoy::config::bootstrap::v3::RuntimeLayer::LayerSpecifierCase::kAdminLayer:

      if (admin_layer_ != nullptr) {

        return absl::InvalidArgumentError(

            "Too many admin layers specified in LayeredRuntime, at most one may be specified");

      }

      admin_layer_ = std::make_unique<AdminLayer>(layer.name(), stats_);

      break;

    case envoy::config::bootstrap::v3::RuntimeLayer::LayerSpecifierCase::kDiskLayer:

      if (watcher_ == nullptr) {

        watcher_ = dispatcher.createFilesystemWatcher();

      }

      creation_status = watcher_->addWatch(layer.disk_layer().symlink_root(),

                                           Filesystem::Watcher::Events::MovedTo,

                                           [this](uint32_t) { return loadNewSnapshot(); });

      RETURN_IF_NOT_OK(creation_status);

      break;

    case envoy::config::bootstrap::v3::RuntimeLayer::LayerSpecifierCase::kRtdsLayer:

      subscriptions_.emplace_back(std::make_unique<RtdsSubscription>(*this, layer.rtds_layer(),

                                                                     store_, validation_visitor));

      init_manager_.add(subscriptions_.back()->init_target_);

      break;

    }

  }

  return loadNewSnapshot();

}

absl::Status LoaderImpl::initialize(Upstream::ClusterManager& cm) {

  cm_ = &cm;

  for (const auto& s : subscriptions_) {

    RETURN_IF_NOT_OK(s->createSubscription());

  }

  return absl::OkStatus();

}

void LoaderImpl::startRtdsSubscriptions(ReadyCallback on_done) {

  on_rtds_initialized_ = on_done;

  init_manager_.initialize(init_watcher_);

}

void LoaderImpl::onRtdsReady() {

  ENVOY_LOG(info, "RTDS has finished initialization");

  on_rtds_initialized_();

}

    : Envoy::Config::SubscriptionBase<envoy::service::runtime::v3::Runtime>(validation_visitor,

                                                                            "name"),

      parent_(parent), config_source_(rtds_layer.rtds_config()), store_(store),

      stats_scope_(store_.createScope("runtime")), resource_name_(rtds_layer.name()),

      init_target_("RTDS " + resource_name_, [this]() { start(); }) {}

absl::Status RtdsSubscription::createSubscription() {

  const auto resource_name = getResourceName();

  auto subscription_or_error = parent_.cm_->subscriptionFactory().subscriptionFromConfigSource(

      config_source_, Grpc::Common::typeUrl(resource_name), *stats_scope_, *this, resource_decoder_,

      {});

  RETURN_IF_NOT_OK(subscription_or_error.status());

  subscription_ = std::move(*subscription_or_error);

  return absl::OkStatus();

}

                                 const std::string&) {

  absl::Status valid = validateUpdateSize(resources.size(), 0);

  if (!valid.ok()) {

    return valid;

  }

  const auto& runtime =

      dynamic_cast<const envoy::service::runtime::v3::Runtime&>(resources[0].get().resource());

  if (runtime.name() != resource_name_) {

    return absl::InvalidArgumentError(

        fmt::format("Unexpected RTDS runtime (expecting {}): {}", resource_name_, runtime.name()));

  }

  ENVOY_LOG(debug, "Reloading RTDS snapshot for onConfigUpdate");

  proto_.CopyFrom(runtime.layer());

  RETURN_IF_NOT_OK(parent_.loadNewSnapshot());

  init_target_.ready();

  return absl::OkStatus();

}

                                 const std::string&) {

  absl::Status valid = validateUpdateSize(added_resources.size(), removed_resources.size());

  if (!valid.ok()) {

  if (!added_resources.empty()) {

    return onConfigUpdate(added_resources, added_resources[0].get().version());

  } else {

    return onConfigRemoved(removed_resources);

  }

}

                                            const EnvoyException*) {

  ASSERT(Envoy::Config::ConfigUpdateFailureReason::ConnectionFailure != reason);

  init_target_.ready();

}

void RtdsSubscription::start() { subscription_->start({resource_name_}); }

                                                  uint32_t removed_resources_num) {

  if (added_resources_num + removed_resources_num != 1) {

    init_target_.ready();

    return absl::InvalidArgumentError(

        fmt::format("Unexpected RTDS resource length, number of added resources "

                    "{}, number of removed resources {}",

                    added_resources_num, removed_resources_num));

  }

  return absl::OkStatus();

}

    const Protobuf::RepeatedPtrField<std::string>& removed_resources) {

  if (removed_resources[0] != resource_name_) {

    return absl::InvalidArgumentError(

        fmt::format("Unexpected removal of unknown RTDS runtime layer {}, expected {}",

                    removed_resources[0], resource_name_));

  }

  ENVOY_LOG(debug, "Clear RTDS snapshot for onConfigUpdate");

  proto_.Clear();

  RETURN_IF_NOT_OK(parent_.loadNewSnapshot());

  init_target_.ready();

  return absl::OkStatus();

}

absl::Status LoaderImpl::loadNewSnapshot() {

  auto snapshot_or_error = createNewSnapshot();

  RETURN_IF_NOT_OK_REF(snapshot_or_error.status());

  std::shared_ptr<SnapshotImpl> ptr = std::move(snapshot_or_error.value());

  tls_->set([ptr](Event::Dispatcher&) -> ThreadLocal::ThreadLocalObjectSharedPtr {

    return std::static_pointer_cast<ThreadLocal::ThreadLocalObject>(ptr);

  });

  refreshReloadableFlags(ptr->values());

  {

    absl::MutexLock lock(snapshot_mutex_);

    thread_safe_snapshot_ = ptr;

  }

  return absl::OkStatus();

}

const Snapshot& LoaderImpl::snapshot() const {

  ASSERT(tls_->currentThreadRegistered(),

         "snapshot can only be called from a worker thread or after the main thread is registered");

  return tls_->getTyped<Snapshot>();

}

SnapshotConstSharedPtr LoaderImpl::threadsafeSnapshot() {

  if (tls_->currentThreadRegistered()) {

    return std::dynamic_pointer_cast<const Snapshot>(tls_->get());

  }

  {

    absl::ReaderMutexLock lock(snapshot_mutex_);

    return thread_safe_snapshot_;

  }

}

absl::Status LoaderImpl::mergeValues(const absl::node_hash_map<std::string, std::string>& values) {

  if (admin_layer_ == nullptr) {

    return absl::InvalidArgumentError("No admin layer specified");

  }

  RETURN_IF_NOT_OK(admin_layer_->mergeValues(values));

  return loadNewSnapshot();

}

void LoaderImpl::countDeprecatedFeatureUse() const { countDeprecatedFeatureUseInternal(stats_); }

RuntimeStats LoaderImpl::generateStats(Stats::Store& store) {

  std::string prefix = "runtime.";

  RuntimeStats stats{

      ALL_RUNTIME_STATS(POOL_COUNTER_PREFIX(store, prefix), POOL_GAUGE_PREFIX(store, prefix))};

  return stats;

}

absl::StatusOr<SnapshotImplPtr> LoaderImpl::createNewSnapshot() {

  std::vector<Snapshot::OverrideLayerConstPtr> layers;

  uint32_t disk_layers = 0;

  uint32_t error_layers = 0;

  uint32_t rtds_layer = 0;

  absl::Status creation_status;

  for (const auto& layer : config_.layers()) {

    switch (layer.layer_specifier_case()) {

    case envoy::config::bootstrap::v3::RuntimeLayer::LayerSpecifierCase::kStaticLayer:

      layers.emplace_back(

          std::make_unique<const ProtoLayer>(layer.name(), layer.static_layer(), creation_status));

      RETURN_IF_NOT_OK(creation_status);

      break;

    case envoy::config::bootstrap::v3::RuntimeLayer::LayerSpecifierCase::kDiskLayer: {

      std::string path =

          layer.disk_layer().symlink_root() + "/" + layer.disk_layer().subdirectory();

      if (layer.disk_layer().append_service_cluster()) {

        absl::StrAppend(&path, "/", service_cluster_);

      }

      if (api_.fileSystem().directoryExists(path)) {

        std::unique_ptr<DiskLayer> disk_layer;

        std::string error;

        TRY_ASSERT_MAIN_THREAD {

          absl::Status creation_status;

          disk_layer = std::make_unique<DiskLayer>(layer.name(), path, api_, creation_status);

          if (!creation_status.ok()) {

            error = creation_status.message();

          }

          END_TRY

        }

        CATCH(EnvoyException & e, { error = e.what(); });

        if (error.empty()) {

          layers.emplace_back(std::move(disk_layer));

          ++disk_layers;

        } else {

          ++error_layers;

          ENVOY_LOG(debug, "error loading runtime values for layer {} from disk: {}",

                    layer.DebugString(), error);

        }

      }

      break;

    }

    case envoy::config::bootstrap::v3::RuntimeLayer::LayerSpecifierCase::kAdminLayer:

      layers.push_back(std::make_unique<AdminLayer>(*admin_layer_));

      break;

    case envoy::config::bootstrap::v3::RuntimeLayer::LayerSpecifierCase::kRtdsLayer: {

      auto* subscription = subscriptions_[rtds_layer++].get();

      layers.emplace_back(

          std::make_unique<const ProtoLayer>(layer.name(), subscription->proto_, creation_status));

      RETURN_IF_NOT_OK(creation_status);

      break;

    }

    }

  }

  stats_.num_layers_.set(layers.size());

  if (error_layers == 0) {

    stats_.load_success_.inc();

  } else {

    stats_.load_error_.inc();

  }

  if (disk_layers > 1) {

    stats_.override_dir_exists_.inc();

  } else {

    stats_.override_dir_not_exists_.inc();

  }

  return std::make_unique<SnapshotImpl>(generator_, stats_, std::move(layers));

}