connection_pool.h

Go to the documentation of this file.

/*
 * Copyright 2026 The A11 Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef A11_NET_HTTP_CONNECTION_POOL_H_
#define A11_NET_HTTP_CONNECTION_POOL_H_
 
#include <memory>
#include <string>
#include <utility>
 
#include <absl/container/flat_hash_map.h>
#include <absl/status/statusor.h>
 
#include "a11/concurrency/future.h"
#include "a11/net/http/url.h"
#include "a11/net/http2.h"
#include "thread/boost_primitives.h"
 
namespace a11::net {
 
class HttpConnectionPool;
 
class HttpConnectionLease {
 public:
  HttpConnectionLease() = default;
 
  [[nodiscard]] const std::shared_ptr<Http2Client>& client() const {
    return client_;
  }
 
  [[nodiscard]] bool reused() const { return reused_; }
 
  [[nodiscard]] bool multiplexed() const;
 
  void Release() { client_.reset(); }
 
 private:
  friend class HttpConnectionPool;
 
  HttpConnectionLease(std::shared_ptr<Http2Client> client, bool reused)
      : client_(std::move(client)), reused_(reused) {}
 
  std::shared_ptr<Http2Client> client_;
  bool reused_ = false;
};
 
class HttpConnectionPool
    : public std::enable_shared_from_this<HttpConnectionPool> {
 public:
  static std::shared_ptr<HttpConnectionPool> Create();
  static const std::shared_ptr<HttpConnectionPool>& Shared();
 
  a11::Future<HttpConnectionLease> Acquire(const ParsedUrl& origin,
                                           Http2Options options);
 
  static a11::Future<HttpConnectionLease> AcquireUnshared(
      const ParsedUrl& origin, Http2Options options);
 
  [[nodiscard]] size_t size() const;
 
 private:
  struct Entry {
    std::weak_ptr<Http2Client> client;
    std::shared_ptr<a11::Promise<std::shared_ptr<Http2Client>>> dialling;
    a11::Future<std::shared_ptr<Http2Client>> dial;
  };
 
  static std::string KeyFor(const ParsedUrl& origin,
                            const Http2Options& options);
 
  void Forget(const std::string& key);
 
  std::shared_ptr<Http2Client> Adopt(std::string key,
                                     std::shared_ptr<Http2Client> client);
 
  mutable thread::Mutex mu_;
  absl::flat_hash_map<std::string, Entry> entries_ ABSL_GUARDED_BY(mu_);
};
 
}  // namespace a11::net
 
#endif  // A11_NET_HTTP_CONNECTION_POOL_H_