createHostMap(const std::string& config, Server::Configuration::ListenerFactoryContext& context) {

  return context.serverFactoryContext().singletonManager().getTyped<const Cilium::PolicyHostMap>(

      "cilium_host_map_singleton", [&config, &context] {

        std::string path = TestEnvironment::writeStringToFileForTest("host_map.yaml", config);

        ENVOY_LOG_MISC(debug, "Loading Cilium Host Map from file \'{}\' instead of using gRPC",

                       path);

        THROW_IF_NOT_OK(Envoy::Config::Utility::checkFilesystemSubscriptionBackingPath(

            path, context.serverFactoryContext().api()));

        Envoy::Config::SubscriptionStats stats =

            Envoy::Config::Utility::generateStats(context.scope());

        auto map = std::make_shared<Cilium::PolicyHostMap>(context.serverFactoryContext());

        auto subscription = std::make_unique<Envoy::Config::FilesystemSubscriptionImpl>(

            context.serverFactoryContext().mainThreadDispatcher(),

            Envoy::Config::makePathConfigSource(path), *map,

            std::make_shared<Cilium::PolicyHostDecoder>(), stats,

            ProtobufMessage::getNullValidationVisitor(), context.serverFactoryContext().api());

        map->startSubscription(std::move(subscription));

        return map;

      });

}

                Server::Configuration::FactoryContext& context) {

  return context.serverFactoryContext().singletonManager().getTyped<const Cilium::NetworkPolicyMap>(

      "cilium_network_policy_singleton", [&config, &secret_configs, &context] {

        if (!secret_configs.empty()) {

          for (const auto& sds_pair : secret_configs) {

            auto& name = sds_pair.first;

            auto& sds_config = sds_pair.second;

            std::string sds_path = TestEnvironment::writeStringToFileForTest(

                fmt::sprintf("secret-%s.yaml", name), sds_config);

            THROW_IF_NOT_OK(Envoy::Config::Utility::checkFilesystemSubscriptionBackingPath(

                sds_path, context.serverFactoryContext().api()));

          }

          Cilium::setSDSConfigFunc(

              [](const std::string& name) -> envoy::config::core::v3::ConfigSource {

                auto file_config = envoy::config::core::v3::ConfigSource();

                file_config.set_resource_api_version(envoy::config::core::v3::ApiVersion::V3);

                auto sds_path =

                    TestEnvironment::temporaryPath(fmt::sprintf("secret-%s.yaml", name));

                *file_config.mutable_path_config_source() =

                    Envoy::Config::makePathConfigSource(sds_path);

                return file_config;

              });

        }

        policy_path = TestEnvironment::writeStringToFileForTest("network_policy.yaml", config);

        ENVOY_LOG_MISC(debug,

                       "Loading Cilium Network Policy from file \'{}\' instead "

                       "of using gRPC",

                       policy_path);

        THROW_IF_NOT_OK(Envoy::Config::Utility::checkFilesystemSubscriptionBackingPath(

            policy_path, context.serverFactoryContext().api()));

        Envoy::Config::SubscriptionStats stats =

            Envoy::Config::Utility::generateStats(context.scope());

        auto map = std::make_shared<Cilium::NetworkPolicyMap>(context);

        auto subscription = std::make_unique<Envoy::Config::FilesystemSubscriptionImpl>(

            context.serverFactoryContext().mainThreadDispatcher(),

            Envoy::Config::makePathConfigSource(policy_path), map->getImpl(),

            std::make_shared<Cilium::NetworkPolicyDecoder>(), stats,

            ProtobufMessage::getNullValidationVisitor(), context.serverFactoryContext().api());

        map->startSubscription(std::move(subscription));

        return map;

      });

}

void initTestMaps(Server::Configuration::ListenerFactoryContext& context) {

  hostmap = createHostMap(host_map_config, context);

  npmap = createPolicyMap(policy_config, sds_configs, context);

}

::cilium::BpfMetadata getTestConfig(const ::cilium::TestBpfMetadata& config) {

  ::cilium::BpfMetadata test_config;

  test_config.set_is_ingress(config.is_ingress());

  test_config.set_is_l7lb(config.is_l7lb());

  return test_config;

}

    : Config(getTestConfig(config), context) {

  hosts_ = hostmap;

  npmap_ = npmap;

}

TestConfig::~TestConfig() {

  hostmap.reset();

  npmap.reset();

}

TestConfig::extractSocketMetadata(Network::ConnectionSocket& socket) {

  socket.setDetectedTransportProtocol("cilium:default");

  socket.setRequestedServerName("localhost");

  std::string pod_ip;

  uint64_t source_identity;

  uint64_t destination_identity;

  if (is_ingress_) {

    source_identity = 1;

    destination_identity = 173;

    pod_ip = original_dst_address->ip()->addressAsString();

    ENVOY_LOG_MISC(debug, "INGRESS POD_IP: {}", pod_ip);

  } else {

    source_identity = 173;

    auto ip = socket.connectionInfoProvider().localAddress()->ip();

    destination_identity = hosts_->resolve(ip);

    pod_ip = ip->addressAsString();

    ENVOY_LOG_MISC(debug, "EGRESS POD_IP: {}", pod_ip);

  }

  const auto& policy = getPolicy(pod_ip);

  auto port = original_dst_address->ip()->port();

  std::string l7proto;

  policy.useProxylib(is_ingress_, proxy_id_, is_ingress_ ? source_identity : destination_identity,

                     port, l7proto);

  return {Cilium::BpfMetadata::SocketMetadata(

      0, 0, source_identity, is_ingress_, is_l7lb_, port, std::move(pod_ip), "", nullptr, nullptr,

      nullptr, original_dst_address, shared_from_this(), 0, std::move(l7proto), "")};

}

      ListenerFactoryContext& context) override {

    initTestMaps(context);

    auto config = std::make_shared<Cilium::BpfMetadata::TestConfig>(

        MessageUtil::downcastAndValidate<const ::cilium::TestBpfMetadata&>(

            proto_config, context.messageValidationVisitor()),

        context);

    return [listener_filter_matcher,

            config](Network::ListenerFilterManager& filter_manager) mutable -> void {

      filter_manager.addAcceptFilter(listener_filter_matcher,

                                     std::make_unique<Cilium::BpfMetadata::Instance>(config));

    };

  }

  ProtobufTypes::MessagePtr createEmptyConfigProto() override {

    return std::make_unique<::cilium::TestBpfMetadata>();

  }

  std::string name() const override { return "test_bpf_metadata"; }