websocket_wire_stream.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_WEBSOCKET_WIRE_STREAM_H_
#define A11_NET_WEBSOCKET_WIRE_STREAM_H_
 
#include <cstdint>
#include <functional>
#include <memory>
#include <string>
 
#include <absl/base/nullability.h>
#include <absl/status/status.h>
#include <absl/status/statusor.h>
 
#include "a11/concurrency/future.h"
#include "a11/net/channel_wire_stream.h"
#include "a11/net/describe_endpoint.h"
#include "a11/net/http2.h"
#include "a11/net/server_headers.h"
#include "a11/net/wire_stream.h"
 
namespace a11::net {
 
struct WebSocketClientOptions {
  Http2Options http2_options;     
  HttpHeaders headers;            
  ChannelFramingOptions framing;  
  absl::Time handshake_deadline = absl::InfiniteFuture();
 
  absl::Status Validate() const;
};
 
class WebSocketWireStream final : public ChannelWireStream {
 private:
  struct ConstructorToken {};
 
 public:
  static absl::StatusOr<std::shared_ptr<WebSocketWireStream>> CreateClient(
      const std::string& url, WireStreamOptions options = {},
      WebSocketClientOptions websocket_options = {});
 
  [[nodiscard]] const std::string& GetRequestPath() const {
    return request_path_;
  }
 
  [[nodiscard]] const HttpHeaders& GetRequestHeaders() const {
    return request_headers_;
  }
 
  explicit WebSocketWireStream(ConstructorToken, std::shared_ptr<State> state)
      : ChannelWireStream(std::move(state)) {}
 
 private:
  static absl::StatusOr<std::shared_ptr<WebSocketWireStream>> CreateAccepted(
      HttpRequest request, std::shared_ptr<Http2ResponseWriter> response,
      WireStreamOptions options, ChannelFramingOptions framing);
 
  // Set once, before the stream is handed to on_stream, and read-only after;
  // no lock, because nothing ever writes them again.
  std::string request_path_;
  HttpHeaders request_headers_;
 
  friend class WebSocketWireServer;
};
 
struct WebSocketServerOptions {
  std::string path = "/a11";  
  std::string path_prefix;
  std::string bind_address = "127.0.0.1";  
  std::uint16_t port = 0;  
  WireStreamOptions stream_options;  
  ChannelFramingOptions framing;     
  Http2Options http2_options;        
  // `GET /actions` on this same port, when something above filled in the
  // handler.
  DescribeEndpointOptions describe;
  // Response-header policy for this port's HTTP surface -- the `Server` header,
  // cross-origin access and cache hints.
  ServerHeaderOptions headers;
 
  absl::Status Validate() const;
};
 
using OnWebSocketStream =
    std::function<a11::Task(std::shared_ptr<WebSocketWireStream>)>;
 
class WebSocketWireServer
    : public std::enable_shared_from_this<WebSocketWireServer> {
 public:
  static absl::StatusOr<std::shared_ptr<WebSocketWireServer>> Create(
      OnWebSocketStream on_stream, WebSocketServerOptions options = {});
  ~WebSocketWireServer();
 
  absl::Status Stop();
  absl::StatusOr<std::uint16_t> port() const;
  [[nodiscard]] bool running() const;
  [[nodiscard]] void* absl_nullable GetImpl() const;
 
 private:
  struct State;
 
  explicit WebSocketWireServer(std::shared_ptr<State> state)
      : state_(std::move(state)) {}
 
  std::shared_ptr<State> state_;
};
 
}  // namespace a11::net
 
#endif  // A11_NET_WEBSOCKET_WIRE_STREAM_H_