ServeMode.h File Reference

#include "Parameters.h"
#include <cstdint>
#include <string>
#include <vector>

Go to the source code of this file.

Classes
struct	eonc::ServeEndpoint
	Configuration for a single serve endpoint. More...
struct	ServeEndpoint
	Configuration for a single serve endpoint. More...

Namespaces
namespace	eonc
	RAII resource manager for the ARTn C library with global synchronization.

Functions
void	eonc::serveMode (const Parameters &params, const std::string &host, uint16_t port)
	Start a single rgpot-compatible Cap'n Proto RPC server.
void	eonc::serveMultiple (const std::vector< ServeEndpoint > &endpoints, const Parameters &params)
	Serve multiple potentials concurrently on different ports.
void	eonc::serveReplicated (const Parameters &params, const std::string &host, uint16_t base_port, size_t replicas)
	Serve N replicas of the same potential across sequential ports.
void	eonc::serveGateway (const Parameters &params, const std::string &host, uint16_t port, size_t pool_size)
	Start a gateway server backed by a pool of potential instances.
void	eonc::serveFromConfig (const Parameters &params)
	Start serve mode from config-file parameters.
std::vector< ServeEndpoint >	eonc::parseServeSpec (const std::string &spec)
	Parse a serve configuration string into endpoints.
std::vector< ServeEndpoint >	parseServeSpec (const std::string &spec)
	Parse a serve configuration string into endpoints.
void	serveFromConfig (const Parameters &params)
	Start serve mode from config-file parameters.
void	serveGateway (const Parameters &params, const std::string &host, uint16_t port, size_t pool_size)
	Start a gateway server backed by a pool of potential instances.
void	serveMode (const Parameters &params, const std::string &host, uint16_t port)
	Start a single rgpot-compatible Cap'n Proto RPC server.
void	serveMultiple (const std::vector< ServeEndpoint > &endpoints, const Parameters &params)
	Serve multiple potentials concurrently on different ports.
void	serveReplicated (const Parameters &params, const std::string &host, uint16_t base_port, size_t replicas)
	Serve N replicas of the same potential across sequential ports.

Function Documentation

parseServeSpec()

std::vector< ServeEndpoint > eonc::parseServeSpec

(

const std::string &

spec

)

Parse a serve configuration string into endpoints.

Accepts comma-separated entries of the form "potential:port" or "potential:host:port". Examples: "lj:12345" "metatomic:12345,lj:12346" "metatomic:0.0.0.0:12345"

Parameters

spec	The comma-separated endpoint specification.

Returns

A vector of ServeEndpoint structs.

Definition at line 229 of file ServeMode.cpp.

                                                               {
  std::vector<ServeEndpoint> endpoints;
  std::istringstream stream(spec);
  std::string token;
 
  while (std::getline(stream, token, ',')) {
    // Trim whitespace
    token.erase(0, token.find_first_not_of(" \t"));
    token.erase(token.find_last_not_of(" \t") + 1);
    if (token.empty())
      continue;
 
    // Parse "potential:port" or "potential:host:port"
    size_t first_colon = token.find(':');
    if (first_colon == std::string::npos) {
      EONC_LOG_ERROR("Invalid serve spec '{}': expected 'potential:port'",
                     token);
      continue;
    }
 
    std::string pot_str = token.substr(0, first_colon);
    std::string rest = token.substr(first_colon + 1);
 
    // Trim parts after colon split
    pot_str.erase(0, pot_str.find_first_not_of(" \t"));
    pot_str.erase(pot_str.find_last_not_of(" \t") + 1);
    rest.erase(0, rest.find_first_not_of(" \t"));
    rest.erase(rest.find_last_not_of(" \t") + 1);
 
    // Lowercase the potential name
    std::transform(pot_str.begin(), pot_str.end(), pot_str.begin(), ::tolower);
 
    ServeEndpoint ep;
    ep.potential =
        magic_enum::enum_cast<PotType>(pot_str, magic_enum::case_insensitive)
            .value_or(PotType::UNKNOWN);
 
    if (ep.potential == PotType::UNKNOWN) {
      EONC_LOG_ERROR("Unknown potential type '{}'", pot_str);
      continue;
    }
 
    size_t second_colon = rest.find(':');
    if (second_colon != std::string::npos) {
      // "host:port" format
      ep.host = rest.substr(0, second_colon);
      ep.host.erase(0, ep.host.find_first_not_of(" \t"));
      ep.host.erase(ep.host.find_last_not_of(" \t") + 1);
      std::string port_str = rest.substr(second_colon + 1);
      port_str.erase(0, port_str.find_first_not_of(" \t"));
      port_str.erase(port_str.find_last_not_of(" \t") + 1);
      ep.port = static_cast<uint16_t>(std::stoi(port_str));
    } else {
      // "port" only
      ep.host = "localhost";
      ep.port = static_cast<uint16_t>(std::stoi(rest));
    }
 
    QUILL_LOG_INFO(eonc::log::get(), "Parsed endpoint: {} on {}:{}",
                   std::string(magic_enum::enum_name(ep.potential)), ep.host,
                   ep.port);
    endpoints.push_back(ep);
  }
 
  return endpoints;
}

serveFromConfig()

void eonc::serveFromConfig

(

const Parameters &

params

)

Start serve mode from config-file parameters.

Reads serve_options from params and dispatches to the appropriate mode:

• If endpoints is set, uses multi-model serve (serveMultiple).
• If gateway_port > 0, uses gateway mode (serveGateway).
• Otherwise, uses replicated mode (serveReplicated).

Parameters

params

The eOn parameters with serve_options populated.

Definition at line 200 of file ServeMode.cpp.

                                               {
  const auto &opts = params.serve_options;
 
  // Multi-model endpoints take priority
  if (!opts.endpoints.empty()) {
    auto endpoints = parseServeSpec(opts.endpoints);
    if (endpoints.empty()) {
      EONC_LOG_ERROR("No valid endpoints in spec: {}", opts.endpoints);
      return;
    }
    serveMultiple(endpoints, params);
    return;
  }
 
  // Gateway mode
  if (opts.gateway_port > 0) {
    size_t pool = (opts.replicas > 0) ? opts.replicas : 1;
    serveGateway(params, opts.host, opts.gateway_port, pool);
    return;
  }
 
  // Replicated mode (default)
  serveReplicated(params, opts.host, opts.port, opts.replicas);
}

serveGateway()

void eonc::serveGateway	(	const Parameters &	params,
		const std::string &	host,
		uint16_t	port,
		size_t	pool_size )

Start a gateway server backed by a pool of potential instances.

Creates pool_size instances of the configured potential and serves them behind a single gateway port. Incoming requests are dispatched round-robin across the pool. This gives clients a single endpoint while spreading load.

Parameters

params	The eOn parameters (potential_options.potential must be set).
host	The hostname to listen on.
port	The gateway port.
pool_size	Number of potential instances in the pool.

Definition at line 167 of file ServeMode.cpp.

                                                   {
  if (pool_size == 0) {
    EONC_LOG_ERROR("Pool size must be >= 1");
    return;
  }
 
  auto pot_type = params.potential_options.potential;
  EONC_LOG_INFO("Creating pool of {} {} instances for gateway on {}:{}",
                pool_size, std::string(magic_enum::enum_name(pot_type)), host,
                port);
 
  std::vector<ForceCallback> pool;
  pool.reserve(pool_size);
 
  for (size_t i = 0; i < pool_size; ++i) {
    auto eon_pot = eonc::helpers::makePotential(params);
    if (!eon_pot) {
      EONC_LOG_ERROR("Failed to create potential instance {}/{}", i + 1,
                     pool_size);
      return;
    }
    pool.push_back(makeForceCallback(std::move(eon_pot)));
  }
 
  EONC_LOG_INFO("Pool ready, starting gateway server");
  startPooledRpcServer(std::move(pool), host, port);
}

serveMode()

void eonc::serveMode	(	const Parameters &	params,
		const std::string &	host,
		uint16_t	port )

Start a single rgpot-compatible Cap'n Proto RPC server.

Wraps eOn's Potential::force() as an rgpot PotentialBase and serves it over Cap'n Proto RPC. Blocks until the server is killed.

Parameters

params	The eOn parameters (potential_options.potential must be set).
host	The hostname to listen on (e.g., "localhost" or "*").
port	The TCP port to listen on.

Definition at line 56 of file ServeMode.cpp.

                              {
  auto pot_type = params.potential_options.potential;
  EONC_LOG_INFO("Creating potential: {}",
                std::string(magic_enum::enum_name(pot_type)));
 
  auto eon_pot = eonc::helpers::makePotential(params);
  if (!eon_pot) {
    EONC_LOG_ERROR("Failed to create potential of type {}",
                   std::string(magic_enum::enum_name(pot_type)));
    return;
  }
 
  auto callback = makeForceCallback(std::move(eon_pot));
 
  // Blocks until killed (runs Cap'n Proto event loop)
  startRpcServer(std::move(callback), host, port);
}

serveMultiple()

void eonc::serveMultiple	(	const std::vector< ServeEndpoint > &	endpoints,
		const Parameters &	params )

Serve multiple potentials concurrently on different ports.

Each endpoint gets its own thread, its own potential instance, and its own Cap'n Proto event loop. All threads block until SIGINT/SIGTERM.

Parameters

endpoints	List of {potential, host, port} configurations.
params	Base eOn parameters (potential type is overridden per endpoint).

Definition at line 79 of file ServeMode.cpp.

                                                  {
  if (endpoints.empty()) {
    EONC_LOG_ERROR("No serve endpoints specified");
    return;
  }
 
  // Single endpoint: run in the main thread (no extra overhead)
  if (endpoints.size() == 1) {
    auto params = base_params;
    params.potential_options.potential = endpoints[0].potential;
    serveMode(params, endpoints[0].host, endpoints[0].port);
    return;
  }
 
  // Multiple endpoints: one thread per server
  EONC_LOG_INFO("Starting {} concurrent RPC servers", endpoints.size());
 
  std::vector<std::thread> threads;
  threads.reserve(endpoints.size());
 
  for (const auto &ep : endpoints) {
    threads.emplace_back([&base_params, ep]() {
      auto params = base_params;
      params.potential_options.potential = ep.potential;
      auto pot_name = std::string(magic_enum::enum_name(ep.potential));
 
      EONC_LOG_INFO("[{}:{}] Creating potential: {}", ep.host, ep.port,
                    pot_name);
 
      auto eon_pot = eonc::helpers::makePotential(params);
      if (!eon_pot) {
        EONC_LOG_ERROR("[{}:{}] Failed to create potential {}", ep.host,
                       ep.port, pot_name);
        return;
      }
 
      auto callback = makeForceCallback(std::move(eon_pot));
      startRpcServer(std::move(callback), ep.host, ep.port);
    });
  }
 
  // Wait for all threads (they block until killed)
  for (auto &t : threads) {
    if (t.joinable()) {
      t.join();
    }
  }
}

serveReplicated()

void eonc::serveReplicated	(	const Parameters &	params,
		const std::string &	host,
		uint16_t	base_port,
		size_t	replicas )

Serve N replicas of the same potential across sequential ports.

Starts replicas threads, each serving the same potential type on ports base_port, base_port+1, ..., base_port+replicas-1.

Parameters

params	The eOn parameters (potential_options.potential must be set).
host	The hostname to listen on.
base_port	The first port; replicas use base_port+0 .. base_port+N-1.
replicas	Number of concurrent server instances.

Definition at line 133 of file ServeMode.cpp.

                                                          {
  if (replicas == 0) {
    EONC_LOG_ERROR("Replicas must be >= 1");
    return;
  }
  if (replicas == 1) {
    serveMode(params, host, base_port);
    return;
  }
 
  EONC_LOG_INFO("Starting {} replicated servers on ports {}-{}", replicas,
                base_port, base_port + replicas - 1);
 
  std::vector<std::thread> threads;
  threads.reserve(replicas);
 
  for (size_t i = 0; i < replicas; ++i) {
    uint16_t port = static_cast<uint16_t>(base_port + i);
    threads.emplace_back(
        [&params, &host, port]() { serveMode(params, host, port); });
  }
 
  for (auto &t : threads) {
    if (t.joinable()) {
      t.join();
    }
  }
}