Broker

type Req = { plan?: string; minutes?: number; dock?: string };
type Handler = (r: Req) => string;

class ServerDown extends Error {}

class Server {
  up = true;
  constructor(readonly name: string, readonly handlers: Record<string, Handler>) {}
  handle(service: string, r: Req): string { if (!this.up) throw new ServerDown(this.name); return this.handlers[service](r); }
}

// Clients name a service; the broker finds a server for it, forwards, and tries another if one fails.
class Broker {
  private registry = new Map<string, Server[]>();
  private turn = new Map<string, number>();
  register(s: Server): void {
    for (const service of Object.keys(s.handlers)) this.registry.set(service, [...(this.registry.get(service) ?? []), s]);
    console.log(`${s.name} registered ${Object.keys(s.handlers).join(", ")}`);
  }
  request(service: string, r: Req): string {
    const servers = this.registry.get(service) ?? [];
    if (!servers.length) return `no server registered for '${service}'`;
    const tried: string[] = [];
    for (let k = 0; k < servers.length; k++) {
      const i = this.turn.get(service) ?? 0;
      this.turn.set(service, (i + 1) % servers.length); // round robin
      const s = servers[i];
      try {
        const answer = s.handle(service, r);
        return `${s.name}${tried.length ? " (after " + tried.join(", ") + " failed)" : ""}: ${answer}`;
      } catch (e) { if (!(e instanceof ServerDown)) throw e; tried.push(s.name); }
    }
    return `all servers for '${service}' failed`;
  }
}

class ClientProxy { // what the rider app's code calls: looks like a local object
  constructor(private broker: Broker) {}
  quote(plan: string, minutes: number): string { return this.broker.request("quote", { plan, minutes }); }
  dockStatus(dock: string): string { return this.broker.request("dock-status", { dock }); }
}

const price: Handler = (r) => String(r.plan === "member" ? Math.max(0, (r.minutes ?? 0) - 30) * 10 : 100 + (r.minutes ?? 0) * 10);

const broker = new Broker();
const p1 = new Server("pricing-1", { quote: price }), p2 = new Server("pricing-2", { quote: price });
for (const s of [p1, p2, new Server("docks-1", { "dock-status": (r) => `${r.dock} has 1 bike` })]) broker.register(s);
const app = new ClientProxy(broker);
console.log("quote(member, 42) -> " + app.quote("member", 42));
console.log("quote(payg, 15) -> " + app.quote("payg", 15));
p1.up = false;
console.log("quote(payg, 20) -> " + app.quote("payg", 20));
console.log("dock_status(D12) -> " + app.dockStatus("D12"));
console.log("weather -> " + broker.request("weather", {}));

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;

class ServerDown extends RuntimeException {
    private static final long serialVersionUID = 1L;
    ServerDown(String name) { super(name); }
}

class Server {
    final String name; final Map<String, Function<Map<String, String>, String>> handlers; boolean up = true;
    Server(String name, Map<String, Function<Map<String, String>, String>> handlers) { this.name = name; this.handlers = handlers; }
    String handle(String service, Map<String, String> r) { if (!up) throw new ServerDown(name); return handlers.get(service).apply(r); }
}

// Clients name a service; the broker finds a server for it, forwards, and tries another if one fails.
class Broker {
    private final Map<String, List<Server>> registry = new HashMap<>();
    private final Map<String, Integer> turn = new HashMap<>();
    void register(Server s) {
        for (String service : s.handlers.keySet()) registry.computeIfAbsent(service, k -> new ArrayList<>()).add(s);
        System.out.println(s.name + " registered " + String.join(", ", s.handlers.keySet()));
    }
    String request(String service, Map<String, String> r) {
        List<Server> servers = registry.getOrDefault(service, List.of());
        if (servers.isEmpty()) return "no server registered for '" + service + "'";
        List<String> tried = new ArrayList<>();
        for (int k = 0; k < servers.size(); k++) {
            int i = turn.getOrDefault(service, 0);
            turn.put(service, (i + 1) % servers.size()); // round robin
            Server s = servers.get(i);
            try {
                String answer = s.handle(service, r);
                return s.name + (tried.isEmpty() ? "" : " (after " + String.join(", ", tried) + " failed)") + ": " + answer;
            } catch (ServerDown e) { tried.add(s.name); }
        }
        return "all servers for '" + service + "' failed";
    }
}

class ClientProxy { // what the rider app's code calls: looks like a local object
    private final Broker broker;
    ClientProxy(Broker broker) { this.broker = broker; }
    String quote(String plan, int minutes) { return broker.request("quote", Map.of("plan", plan, "minutes", String.valueOf(minutes))); }
    String dockStatus(String dock) { return broker.request("dock-status", Map.of("dock", dock)); }
}

public class Main {
    static String price(Map<String, String> r) {
        int m = Integer.parseInt(r.get("minutes"));
        return String.valueOf(r.get("plan").equals("member") ? Math.max(0, m - 30) * 10 : 100 + m * 10);
    }
    public static void main(String[] args) {
        Broker broker = new Broker();
        Map<String, Function<Map<String, String>, String>> pricing = new LinkedHashMap<>();
        pricing.put("quote", Main::price);
        Server p1 = new Server("pricing-1", pricing), p2 = new Server("pricing-2", pricing);
        Map<String, Function<Map<String, String>, String>> docks = new LinkedHashMap<>();
        docks.put("dock-status", r -> r.get("dock") + " has 1 bike");
        for (Server s : List.of(p1, p2, new Server("docks-1", docks))) broker.register(s);
        ClientProxy app = new ClientProxy(broker);
        System.out.println("quote(member, 42) -> " + app.quote("member", 42));
        System.out.println("quote(payg, 15) -> " + app.quote("payg", 15));
        p1.up = false;
        System.out.println("quote(payg, 20) -> " + app.quote("payg", 20));
        System.out.println("dock_status(D12) -> " + app.dockStatus("D12"));
        System.out.println("weather -> " + broker.request("weather", Map.of()));
    }
}