async-grpc-xds 0.0.1

data/lib/async/grpc/xds/load_balancer.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require "async"
+require "async/http/endpoint"
+require_relative "health_checker"
+require_relative "resources"
+
+module Async
+	module GRPC
+		module XDS
+			# Client-side load balancing with health checking.
+			# RING_HASH and MAGLEV fall back to round-robin (require request context to hash).
+			class LoadBalancer
+				# Load balancing policies.
+				ROUND_ROBIN = :round_robin
+				LEAST_REQUEST = :least_request
+				RANDOM = :random
+				RING_HASH = :ring_hash
+				MAGLEV = :maglev
+				
+				# Initialize load balancer
+				# @parameter cluster [Resources::Cluster] Cluster configuration
+				# @parameter endpoints [Array<Async::HTTP::Endpoint>] Initial endpoints
+				def initialize(cluster, endpoints)
+					@cluster = cluster
+					@endpoints = endpoints
+					@policy = parse_policy(cluster.load_balancer_policy)
+					@health_status = {}  # Track health per endpoint
+					@health_checker = HealthChecker.new(cluster.health_checks)
+					@current_index = 0
+					@in_flight_requests = {}  # Track in-flight requests per endpoint
+					@health_check_task = nil  # Transient task for health check loop
+					
+					# Initialize health status
+					@endpoints.each do |endpoint|
+						@health_status[endpoint] = :unknown
+					end
+					
+					# Start health checking if configured
+					start_health_checks if cluster.health_checks.any?
+				end
+				
+				# Get healthy endpoints
+				# @returns [Array<Async::HTTP::Endpoint>] Healthy endpoints
+				def healthy_endpoints
+					@endpoints.select{|endpoint| healthy?(endpoint)}
+				end
+				
+				# Pick next endpoint using load balancing policy
+				# @returns [Async::HTTP::Endpoint, nil] Selected endpoint
+				def pick
+					healthy = healthy_endpoints
+					return nil if healthy.empty?
+					
+					case @policy
+					when ROUND_ROBIN
+						pick_round_robin(healthy)
+					when LEAST_REQUEST
+						pick_least_request(healthy)
+					when RANDOM
+						pick_random(healthy)
+					when RING_HASH
+						pick_ring_hash(healthy)
+					when MAGLEV
+						pick_maglev(healthy)
+					else
+						healthy.first
+					end
+				end
+				
+				# Update endpoints from EDS
+				# @parameter endpoints [Array<Async::HTTP::Endpoint>] New endpoints
+				def update_endpoints(endpoints)
+					old_endpoints = @endpoints
+					@endpoints = endpoints
+					
+					# Update health checker
+					@health_checker.update_endpoints(endpoints)
+					
+					# Initialize health status for new endpoints
+					endpoints.each do |endpoint|
+						@health_status[endpoint] ||= :unknown
+					end
+					
+					# Remove state for old endpoints
+					(old_endpoints - endpoints).each do |endpoint|
+						@health_status.delete(endpoint)
+						@in_flight_requests.delete(endpoint)
+					end
+				end
+				
+				# Record that a request has started for the given endpoint.
+				# Used by LEAST_REQUEST policy. Call from Client when a call begins.
+				# @parameter endpoint [Async::HTTP::Endpoint] The endpoint handling the request
+				def record_request_start(endpoint)
+					@in_flight_requests[endpoint] ||= 0
+					@in_flight_requests[endpoint] += 1
+				end
+				
+				# Record that a request has finished for the given endpoint.
+				# Must be called in ensure to decrement even on error/retry.
+				# @parameter endpoint [Async::HTTP::Endpoint] The endpoint that handled the request
+				def record_request_end(endpoint)
+					return unless endpoint
+					current = @in_flight_requests[endpoint]
+					return unless current && current > 0
+					@in_flight_requests[endpoint] = current - 1
+					@in_flight_requests.delete(endpoint) if @in_flight_requests[endpoint] == 0
+				end
+				
+				# Mark endpoint as unhealthy (e.g. after connection failure).
+				# Health checker may restore it on next successful check.
+				# @parameter endpoint [Async::HTTP::Endpoint] The endpoint to mark unhealthy
+				def mark_unhealthy(endpoint)
+					@health_status[endpoint] = :unhealthy
+				end
+				
+				# Close load balancer
+				def close
+					if health_check_task = @health_check_task
+						@health_check_task = nil
+						health_check_task.stop
+					end
+					
+					@health_checker.close
+				end
+				
+			private
+				
+				def healthy?(endpoint)
+					status = @health_status[endpoint]
+					status == :healthy || status == :unknown
+				end
+				
+				def pick_round_robin(endpoints)
+					@current_index = (@current_index + 1) % endpoints.size
+					endpoints[@current_index]
+				end
+				
+				def pick_least_request(endpoints)
+					# Track in-flight requests and pick endpoint with fewest
+					endpoints.min_by{|endpoint| @in_flight_requests[endpoint] || 0}
+				end
+				
+				def pick_random(endpoints)
+					endpoints.sample
+				end
+				
+				def pick_ring_hash(endpoints)
+					pick_round_robin(endpoints)  # Fallback; requires request context for consistent hashing
+				end
+				
+				def pick_maglev(endpoints)
+					pick_round_robin(endpoints)  # Fallback; requires request context for Maglev hashing
+				end
+				
+				def parse_policy(load_balancer_policy)
+					# Parse cluster load balancer policy to our constants
+					case load_balancer_policy
+					when :ROUND_ROBIN, "ROUND_ROBIN"
+						ROUND_ROBIN
+					when :LEAST_REQUEST, "LEAST_REQUEST"
+						LEAST_REQUEST
+					when :RANDOM, "RANDOM"
+						RANDOM
+					when :RING_HASH, "RING_HASH"
+						RING_HASH
+					when :MAGLEV, "MAGLEV"
+						MAGLEV
+					else
+						ROUND_ROBIN  # Default
+					end
+				end
+				
+				def start_health_checks
+					return unless @cluster.health_checks.any?
+					
+					@health_check_task = Async(transient: true) do
+						loop do
+							@endpoints.each do |endpoint|
+								@health_status[endpoint] = @health_checker.check(endpoint)
+							end
+							
+							# Sleep for health check interval
+							interval = @cluster.health_checks.first[:interval] || 30
+							sleep(interval)
+						end
+					end
+				end
+			end
+		end
+	end
+end

data/lib/async/grpc/xds/resource_builder.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require "google/protobuf/any_pb"
+require "google/protobuf/duration_pb"
+
+require "envoy/config/cluster/v3/cluster_pb"
+require "envoy/config/core/v3/address_pb"
+require "envoy/config/core/v3/config_source_pb"
+require "envoy/config/core/v3/health_check_pb"
+require "envoy/config/core/v3/protocol_pb"
+require "envoy/config/endpoint/v3/endpoint_pb"
+require "envoy/config/endpoint/v3/endpoint_components_pb"
+
+module Async
+	module GRPC
+		module XDS
+			# Builds Envoy xDS resource protobufs.
+			module ResourceBuilder
+				TYPE_URL_PREFIX = "type.googleapis.com"
+				
+				CLUSTER_TYPE = "#{TYPE_URL_PREFIX}/envoy.config.cluster.v3.Cluster"
+				ENDPOINT_TYPE = "#{TYPE_URL_PREFIX}/envoy.config.endpoint.v3.ClusterLoadAssignment"
+				
+				def self.pack(resource)
+					Google::Protobuf::Any.new(
+						type_url: "#{TYPE_URL_PREFIX}/#{resource.class.descriptor.name}",
+						value: resource.to_proto
+					)
+				end
+				
+				def self.cluster(name, service_name: name, load_balancer_policy: :round_robin, connect_timeout: 5)
+					Envoy::Config::Cluster::V3::Cluster.new(
+						name: name.to_s,
+						type: Envoy::Config::Cluster::V3::Cluster::DiscoveryType::EDS,
+						eds_cluster_config: Envoy::Config::Cluster::V3::Cluster::EdsClusterConfig.new(
+							service_name: service_name.to_s,
+							eds_config: Envoy::Config::Core::V3::ConfigSource.new(
+								ads: Envoy::Config::Core::V3::AggregatedConfigSource.new
+							)
+						),
+						connect_timeout: duration(connect_timeout),
+						lb_policy: load_balancer_policy_value(load_balancer_policy),
+						http2_protocol_options: Envoy::Config::Core::V3::Http2ProtocolOptions.new
+					)
+				end
+				
+				def self.cluster_load_assignment(cluster_name, endpoints)
+					Envoy::Config::Endpoint::V3::ClusterLoadAssignment.new(
+						cluster_name: cluster_name.to_s,
+						endpoints: [
+							Envoy::Config::Endpoint::V3::LocalityLbEndpoints.new(
+								lb_endpoints: endpoints.map{|endpoint| load_balancer_endpoint(endpoint)}
+							)
+						]
+					)
+				end
+					
+				def self.load_balancer_endpoint(endpoint)
+					endpoint = normalize_endpoint(endpoint)
+						
+					Envoy::Config::Endpoint::V3::LbEndpoint.new(
+						endpoint: Envoy::Config::Endpoint::V3::Endpoint.new(
+							address: Envoy::Config::Core::V3::Address.new(
+								socket_address: Envoy::Config::Core::V3::SocketAddress.new(
+									protocol: Envoy::Config::Core::V3::SocketAddress::Protocol::TCP,
+									address: endpoint[:address],
+									port_value: endpoint[:port]
+								)
+							),
+							hostname: endpoint[:hostname].to_s
+						),
+						health_status: health_status_value(endpoint.fetch(:healthy, true))
+					)
+				end
+					
+				def self.normalize_endpoint(endpoint)
+					case endpoint
+					when Hash
+						{
+							address: endpoint.fetch(:address){endpoint.fetch("address")},
+							port: endpoint.fetch(:port){endpoint.fetch("port")}.to_i,
+							hostname: endpoint[:hostname] || endpoint["hostname"],
+							healthy: endpoint.key?(:healthy) ? endpoint[:healthy] : endpoint.fetch("healthy", true)
+						}
+					else
+						if endpoint.respond_to?(:address) && endpoint.respond_to?(:port)
+							{
+								address: endpoint.address,
+								port: endpoint.port.to_i,
+								hostname: endpoint.respond_to?(:hostname) ? endpoint.hostname : nil,
+								healthy: endpoint.respond_to?(:healthy?) ? endpoint.healthy? : true
+							}
+						else
+							raise ArgumentError, "Invalid endpoint: #{endpoint.inspect}"
+						end
+					end
+				end
+					
+				def self.duration(seconds)
+					whole_seconds = seconds.to_i
+					nanos = ((seconds.to_f - whole_seconds) * 1_000_000_000).to_i
+						
+					Google::Protobuf::Duration.new(seconds: whole_seconds, nanos: nanos)
+				end
+					
+				def self.load_balancer_policy_value(load_balancer_policy)
+					case load_balancer_policy
+					when :round_robin, :ROUND_ROBIN, "round_robin", "ROUND_ROBIN"
+						Envoy::Config::Cluster::V3::Cluster::LbPolicy::ROUND_ROBIN
+					when :least_request, :LEAST_REQUEST, "least_request", "LEAST_REQUEST"
+						Envoy::Config::Cluster::V3::Cluster::LbPolicy::LEAST_REQUEST
+					when :random, :RANDOM, "random", "RANDOM"
+						Envoy::Config::Cluster::V3::Cluster::LbPolicy::RANDOM
+					else
+						load_balancer_policy
+					end
+				end
+					
+				def self.health_status_value(healthy)
+					case healthy
+					when :healthy, :HEALTHY, "healthy", "HEALTHY", true
+						Envoy::Config::Core::V3::HealthStatus::HEALTHY
+					when :unhealthy, :UNHEALTHY, "unhealthy", "UNHEALTHY", false
+						Envoy::Config::Core::V3::HealthStatus::UNHEALTHY
+					when :degraded, :DEGRADED, "degraded", "DEGRADED"
+						Envoy::Config::Core::V3::HealthStatus::DEGRADED
+					else
+						Envoy::Config::Core::V3::HealthStatus::UNKNOWN
+					end
+				end
+			end
+		end
+	end
+end
+	

data/lib/async/grpc/xds/resource_cache.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+module Async
+	module GRPC
+		module XDS
+			# Caches discovered xDS resources
+			# Thread-safe cache for clusters and endpoints
+			class ResourceCache
+				def initialize
+					@clusters = {}
+					@endpoints = {}
+					@mutex = Mutex.new
+				end
+				
+				# Get cluster by name
+				# @parameter name [String] Cluster name
+				# @returns [Resources::Cluster, nil] Cached cluster or nil
+				def get_cluster(name)
+					@mutex.synchronize{@clusters[name]}
+				end
+				
+				# Update cluster in cache
+				# @parameter cluster [Resources::Cluster] Cluster to cache
+				def update_cluster(cluster)
+					@mutex.synchronize{@clusters[cluster.name] = cluster}
+				end
+				
+				# Get endpoints for cluster
+				# @parameter cluster_name [String] Cluster name
+				# @returns [Array<Async::HTTP::Endpoint>, nil] Cached endpoints or nil
+				def get_endpoints(cluster_name)
+					@mutex.synchronize{@endpoints[cluster_name]}
+				end
+				
+				# Update endpoints for cluster
+				# @parameter cluster_name [String] Cluster name
+				# @parameter endpoints [Array<Async::HTTP::Endpoint>] Endpoints to cache
+				def update_endpoints(cluster_name, endpoints)
+					@mutex.synchronize{@endpoints[cluster_name] = endpoints}
+				end
+				
+				# Clear all cached resources
+				def clear
+					@mutex.synchronize do
+						@clusters.clear
+						@endpoints.clear
+					end
+				end
+			end
+		end
+	end
+end

data/lib/async/grpc/xds/resources.rb

@@ -0,0 +1,270 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+module Async
+	module GRPC
+		module XDS
+			module Resources
+				# Represents a discovered cluster
+				# Based on envoy.config.cluster.v3.Cluster
+				class Cluster
+					attr_reader :name, :type, :load_balancer_policy, :health_checks, :circuit_breakers, :eds_cluster_config
+					
+					# Initialize cluster from protobuf or hash
+					# @parameter data [Object, Hash] Cluster protobuf or hash representation
+					def initialize(data)
+						if data.is_a?(Hash)
+							@name = data[:name]
+							@type = parse_type(data[:type])
+							@load_balancer_policy = parse_load_balancer_policy(data[:load_balancer_policy] || data[:lb_policy])
+							@health_checks = parse_health_checks(data[:health_checks] || [])
+							@circuit_breakers = data[:circuit_breakers]
+							@eds_cluster_config = data[:eds_cluster_config]
+						else
+							# Assume protobuf object
+							@name = data.name
+							@type = parse_type(data.type)
+							@load_balancer_policy = parse_load_balancer_policy(data.lb_policy)
+							@health_checks = parse_health_checks(data.health_checks || [])
+							@circuit_breakers = data.circuit_breakers
+							@eds_cluster_config = data.eds_cluster_config
+						end
+					end
+					
+					# Create Cluster from protobuf message
+					# @parameter proto [Envoy::Config::Cluster::V3::Cluster] Protobuf cluster
+					# @returns [Cluster] Cluster instance
+					def self.from_proto(proto)
+						new(proto)
+					end
+					
+					def eds_cluster?
+						@type == :EDS
+					end
+					
+					private
+					
+					def parse_type(type)
+						# Handle protobuf enum values (integers) or symbols/strings
+						case type
+						when :EDS, "EDS", "envoy.config.cluster.v3.Cluster.EDS", 3
+							:EDS
+						when :STATIC, "STATIC", "envoy.config.cluster.v3.Cluster.STATIC", 0
+							:STATIC
+						when :LOGICAL_DNS, "LOGICAL_DNS", "envoy.config.cluster.v3.Cluster.LOGICAL_DNS", 2
+							:LOGICAL_DNS
+						when :STRICT_DNS, "STRICT_DNS", "envoy.config.cluster.v3.Cluster.STRICT_DNS", 1
+							:STRICT_DNS
+						else
+							# Default to EDS for unknown types
+							:EDS
+						end
+					end
+					
+					def parse_load_balancer_policy(policy)
+						# Handle protobuf enum values (integers) or symbols/strings
+						case policy
+						when :ROUND_ROBIN, "ROUND_ROBIN", "envoy.config.cluster.v3.Cluster.ROUND_ROBIN", 0
+							:ROUND_ROBIN
+						when :LEAST_REQUEST, "LEAST_REQUEST", "envoy.config.cluster.v3.Cluster.LEAST_REQUEST", 1
+							:LEAST_REQUEST
+						when :RANDOM, "RANDOM", "envoy.config.cluster.v3.Cluster.RANDOM", 3
+							:RANDOM
+						when :RING_HASH, "RING_HASH", "envoy.config.cluster.v3.Cluster.RING_HASH", 2
+							:RING_HASH
+						when :MAGLEV, "MAGLEV", "envoy.config.cluster.v3.Cluster.MAGLEV", 5
+							:MAGLEV
+						else
+							# Default to ROUND_ROBIN
+							:ROUND_ROBIN
+						end
+					end
+					
+					def parse_health_checks(checks)
+						Array(checks).map do |check|
+							if check.is_a?(Hash)
+								{
+									type: parse_health_check_type(check[:health_checker] || check[:type] || :HTTP),
+									timeout: parse_duration(check[:timeout]),
+									interval: parse_duration(check[:interval] || 30),
+									path: extract_http_path(check)
+								}
+							else
+								# Protobuf HealthCheck object
+								{
+									type: parse_health_check_type(check.health_checker),
+									timeout: parse_duration(check.timeout),
+									interval: parse_duration(check.interval),
+									path: extract_http_path_from_proto(check)
+								}
+							end
+						end
+					end
+					
+					def parse_health_check_type(checker)
+						# Handle protobuf HealthCheck.health_checker oneof
+						# checker is the health_checker field from HealthCheck protobuf
+						return :HTTP if checker.nil?
+						
+						case checker
+						when :http_health_check
+							:HTTP
+						when :grpc_health_check
+							:gRPC
+						when :tcp_health_check
+							:TCP
+						when Hash
+							checker_type = checker[:type]
+							case checker_type
+							when :HTTP, "HTTP", "envoy.config.core.v3.HealthCheck.HttpHealthCheck"
+								:HTTP
+							when :gRPC, "gRPC", "envoy.config.core.v3.HealthCheck.GrpcHealthCheck"
+								:gRPC
+							when :TCP, "TCP", "envoy.config.core.v3.HealthCheck.TcpHealthCheck"
+								:TCP
+							else
+								:HTTP  # Default
+							end
+						else
+							# Protobuf HealthCheck object - check which oneof field is set
+							# The health_checker is a oneof, so we check which field is populated
+							if checker.respond_to?(:http_health_check) && checker.http_health_check
+								:HTTP
+							elsif checker.respond_to?(:grpc_health_check) && checker.grpc_health_check
+								:gRPC
+							elsif checker.respond_to?(:tcp_health_check) && checker.tcp_health_check
+								:TCP
+							else
+								:HTTP  # Default
+							end
+						end
+					end
+					
+					def parse_duration(duration)
+						# Convert protobuf Duration to seconds (float)
+						return duration if duration.is_a?(Numeric)
+						return nil unless duration
+						
+						# If it's a protobuf Duration, convert to seconds
+						if duration.respond_to?(:seconds) && duration.respond_to?(:nanos)
+							duration.seconds + (duration.nanos.to_f / 1_000_000_000)
+						else
+							duration.to_f
+						end
+					end
+					
+					def extract_http_path(check)
+						# Extract HTTP path from hash
+						return nil unless check.is_a?(Hash)
+						
+						http_check = check[:http_health_check] || {}
+						http_check[:path] || "/health"
+					end
+					
+					def extract_http_path_from_proto(check)
+						# Extract HTTP path from protobuf HealthCheck
+						return nil unless check.respond_to?(:http_health_check)
+						
+						http_check = check.http_health_check
+						return nil unless http_check
+						
+						http_check.path || "/health"
+					end
+				end
+				
+				# Represents endpoint assignment (ClusterLoadAssignment)
+				# Based on envoy.config.endpoint.v3.ClusterLoadAssignment
+				class ClusterLoadAssignment
+					attr_reader :cluster_name, :endpoints
+					
+					# Initialize from protobuf or hash
+					# @parameter data [Object, Hash] ClusterLoadAssignment protobuf or hash
+					def initialize(data)
+						if data.is_a?(Hash)
+							@cluster_name = data[:cluster_name]
+							@endpoints = parse_endpoints(data[:endpoints] || [])
+						else
+							@cluster_name = data.cluster_name
+							@endpoints = parse_endpoints(data.endpoints || [])
+						end
+					end
+					
+					# Create ClusterLoadAssignment from protobuf message
+					# @parameter proto [Envoy::Config::Endpoint::V3::ClusterLoadAssignment] Protobuf assignment
+					# @returns [ClusterLoadAssignment] Assignment instance
+					def self.from_proto(proto)
+						new(proto)
+					end
+					
+					private
+					
+					def parse_endpoints(endpoints_data)
+						Array(endpoints_data).flat_map do |locality_endpoints|
+							load_balancer_endpoints = locality_endpoints.is_a?(Hash) ?
+								(locality_endpoints[:lb_endpoints] || []) :
+								(locality_endpoints.lb_endpoints || [])
+							
+							load_balancer_endpoints.map{|load_balancer_endpoint| Endpoint.new(load_balancer_endpoint)}
+						end
+					end
+				end
+				
+				# Represents a single endpoint
+				# Based on envoy.config.endpoint.v3.LbEndpoint
+				class Endpoint
+					attr_reader :address, :port, :health_status, :metadata
+					
+					def initialize(load_balancer_endpoint)
+						if load_balancer_endpoint.is_a?(Hash)
+							endpoint_data = load_balancer_endpoint[:endpoint] || {}
+							address_data = endpoint_data[:address] || {}
+							socket_address = address_data[:socket_address] || {}
+							
+							@address = socket_address[:address] || "localhost"
+							@port = socket_address[:port_value] || 50051
+							@health_status = parse_health_status(load_balancer_endpoint[:health_status])
+							@metadata = load_balancer_endpoint[:metadata] || {}
+						else
+							socket_address = load_balancer_endpoint.endpoint.address.socket_address
+							@address = socket_address.address
+							@port = socket_address.port_value
+							@health_status = parse_health_status(load_balancer_endpoint.health_status)
+							@metadata = load_balancer_endpoint.metadata || {}
+						end
+					end
+					
+					def healthy?
+						@health_status == :HEALTHY || @health_status == :UNKNOWN
+					end
+					
+					def uri
+						# Use http for insecure/docker environments (gRPC h2c)
+						scheme = ENV["XDS_ENDPOINT_SCHEME"] || "http"
+						"#{scheme}://#{@address}:#{@port}"
+					end
+					
+					private
+					
+					def parse_health_status(status)
+						# Handle protobuf enum values (integers) or symbols/strings
+						# HealthStatus is defined in envoy.config.endpoint.v3.Endpoint
+						case status
+						when :HEALTHY, "HEALTHY", 0
+							:HEALTHY
+						when :UNHEALTHY, "UNHEALTHY", 1
+							:UNHEALTHY
+						when :DEGRADED, "DEGRADED", 2
+							:DEGRADED
+						when :UNKNOWN, "UNKNOWN", 3, nil
+							:UNKNOWN
+						else
+							:UNKNOWN
+						end
+					end
+				end
+			end
+		end
+	end
+end

data/lib/async/grpc/xds/server.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require "async/grpc/dispatcher"
+require "async/http/server"
+
+require_relative "control_plane"
+require_relative "service"
+
+module Async
+	module GRPC
+		module XDS
+			# Convenience wrapper for serving an xDS control plane over gRPC.
+			class Server
+				def initialize(control_plane = ControlPlane.new, **options)
+					@control_plane = control_plane
+					@dispatcher = Async::GRPC::Dispatcher.new
+					@dispatcher.register(Service.new(@control_plane))
+					@options = options
+				end
+				
+				attr :control_plane
+				attr :dispatcher
+				
+				def run(endpoint, **options)
+					server = Async::HTTP::Server.new(@dispatcher, endpoint, **@options, **options)
+					server.run
+				end
+			end
+		end
+	end
+end